borsapy 0.1.0__py3-none-any.whl

borsapy/__init__.py

@@ -0,0 +1,92 @@
+"""
+borsapy - Turkish Financial Markets Data Library
+
+A yfinance-like API for BIST stocks, forex, crypto, funds, and economic data.
+
+Examples:
+    >>> import borsapy as bp
+
+    # Get stock data
+    >>> stock = bp.Ticker("THYAO")
+    >>> stock.info  # Real-time quote
+    >>> stock.history(period="1mo")  # OHLCV data
+    >>> stock.balance_sheet  # Financial statements
+
+    # Get forex/commodity data
+    >>> usd = bp.FX("USD")
+    >>> usd.current  # Current rate
+    >>> usd.history(period="1mo")  # Historical data
+    >>> gold = bp.FX("gram-altin")
+
+    # List all BIST companies
+    >>> bp.companies()
+    >>> bp.search_companies("banka")
+
+    # Get crypto data
+    >>> btc = bp.Crypto("BTCTRY")
+    >>> btc.current  # Current price
+    >>> btc.history(period="1mo")  # Historical OHLCV
+    >>> bp.crypto_pairs()  # List available pairs
+
+    # Get fund data
+    >>> fund = bp.Fund("AAK")
+    >>> fund.info  # Fund details
+    >>> fund.history(period="1mo")  # Price history
+
+    # Get inflation data
+    >>> inf = bp.Inflation()
+    >>> inf.latest()  # Latest TÜFE data
+    >>> inf.calculate(100000, "2020-01", "2024-01")  # Inflation calculation
+"""
+
+from borsapy.crypto import Crypto, crypto_pairs
+from borsapy.exceptions import (
+    APIError,
+    AuthenticationError,
+    BorsapyError,
+    DataNotAvailableError,
+    InvalidIntervalError,
+    InvalidPeriodError,
+    RateLimitError,
+    TickerNotFoundError,
+)
+from borsapy.fund import Fund, search_funds
+from borsapy.fx import FX
+from borsapy.index import Index, index, indices
+from borsapy.inflation import Inflation
+from borsapy.market import companies, search_companies
+from borsapy.multi import Tickers, download
+from borsapy.ticker import Ticker
+from borsapy.viop import VIOP
+
+__version__ = "0.1.0"
+__author__ = "Said Surucu"
+
+__all__ = [
+    # Main classes
+    "Ticker",
+    "Tickers",
+    "FX",
+    "Crypto",
+    "Fund",
+    "Index",
+    "Inflation",
+    "VIOP",
+    # Market functions
+    "companies",
+    "search_companies",
+    "crypto_pairs",
+    "search_funds",
+    "download",
+    "index",
+    "indices",
+    # Exceptions
+    "BorsapyError",
+    "TickerNotFoundError",
+    "DataNotAvailableError",
+    "APIError",
+    "AuthenticationError",
+    "RateLimitError",
+    "InvalidPeriodError",
+    "InvalidIntervalError",
+]

borsapy/_models/__init__.py

@@ -0,0 +1 @@
+"""Data models for borsapy."""

borsapy/_providers/__init__.py

@@ -0,0 +1,5 @@
+"""Data providers for borsapy."""
+
+from borsapy._providers.base import BaseProvider
+
+__all__ = ["BaseProvider"]

borsapy/_providers/base.py

@@ -0,0 +1,94 @@
+"""Base provider class for all data providers."""
+
+from typing import Any
+
+import httpx
+
+from borsapy.cache import Cache, get_cache
+
+
+class BaseProvider:
+    """Base class for all data providers."""
+
+    DEFAULT_HEADERS = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "application/json, text/plain, */*",
+        "Accept-Language": "tr-TR,tr;q=0.9,en-US;q=0.8,en;q=0.7",
+    }
+
+    def __init__(
+        self,
+        timeout: float = 30.0,
+        cache: Cache | None = None,
+    ):
+        """
+        Initialize the provider.
+
+        Args:
+            timeout: HTTP request timeout in seconds.
+            cache: Cache instance to use. If None, uses global cache.
+        """
+        self._client = httpx.Client(timeout=timeout, headers=self.DEFAULT_HEADERS)
+        self._cache = cache or get_cache()
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def _get(
+        self,
+        url: str,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> httpx.Response:
+        """
+        Make a GET request.
+
+        Args:
+            url: Request URL.
+            params: Query parameters.
+            headers: Request headers.
+
+        Returns:
+            HTTP response.
+        """
+        response = self._client.get(url, params=params, headers=headers)
+        response.raise_for_status()
+        return response
+
+    def _post(
+        self,
+        url: str,
+        data: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> httpx.Response:
+        """
+        Make a POST request.
+
+        Args:
+            url: Request URL.
+            data: Form data.
+            json: JSON data.
+            headers: Request headers.
+
+        Returns:
+            HTTP response.
+        """
+        response = self._client.post(url, data=data, json=json, headers=headers)
+        response.raise_for_status()
+        return response
+
+    def _cache_get(self, key: str) -> Any | None:
+        """Get a value from cache."""
+        return self._cache.get(key)
+
+    def _cache_set(self, key: str, value: Any, ttl: int) -> None:
+        """Set a value in cache."""
+        self._cache.set(key, value, ttl)

borsapy/_providers/btcturk.py

@@ -0,0 +1,230 @@
+"""BtcTurk provider for cryptocurrency data."""
+
+from datetime import datetime, timedelta
+from typing import Any
+
+import pandas as pd
+
+from borsapy._providers.base import BaseProvider
+from borsapy.cache import TTL
+from borsapy.exceptions import APIError, DataNotAvailableError
+
+
+class BtcTurkProvider(BaseProvider):
+    """
+    Provider for cryptocurrency data from BtcTurk.
+
+    Provides:
+    - Real-time ticker data for crypto pairs
+    - Historical OHLC data
+    """
+
+    BASE_URL = "https://api.btcturk.com/api/v2"
+    GRAPH_API_URL = "https://graph-api.btcturk.com"
+
+    # Resolution mapping (minutes)
+    RESOLUTION_MAP = {
+        "1m": 1,
+        "5m": 5,
+        "15m": 15,
+        "30m": 30,
+        "1h": 60,
+        "4h": 240,
+        "1d": 1440,
+        "1wk": 10080,
+    }
+
+    def get_ticker(self, pair: str) -> dict[str, Any]:
+        """
+        Get current ticker data for a crypto pair.
+
+        Args:
+            pair: Trading pair (e.g., "BTCTRY", "ETHTRY", "BTCUSDT")
+
+        Returns:
+            Dictionary with ticker data.
+        """
+        pair = pair.upper()
+
+        cache_key = f"btcturk:ticker:{pair}"
+        cached = self._cache_get(cache_key)
+        if cached is not None:
+            return cached
+
+        try:
+            url = f"{self.BASE_URL}/ticker"
+            params = {"pairSymbol": pair}
+
+            response = self._client.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+
+            if not data.get("success", False):
+                raise APIError(f"API error: {data.get('message', 'Unknown')}")
+
+            ticker_data = data.get("data", [])
+            if not ticker_data:
+                raise DataNotAvailableError(f"No data for pair: {pair}")
+
+            ticker = ticker_data[0] if isinstance(ticker_data, list) else ticker_data
+
+            result = {
+                "symbol": ticker.get("pair"),
+                "last": float(ticker.get("last", 0)),
+                "open": float(ticker.get("open", 0)),
+                "high": float(ticker.get("high", 0)),
+                "low": float(ticker.get("low", 0)),
+                "bid": float(ticker.get("bid", 0)),
+                "ask": float(ticker.get("ask", 0)),
+                "volume": float(ticker.get("volume", 0)),
+                "change": float(ticker.get("daily", 0)),
+                "change_percent": float(ticker.get("dailyPercent", 0)),
+                "timestamp": ticker.get("timestamp"),
+            }
+
+            self._cache_set(cache_key, result, TTL.REALTIME_PRICE)
+            return result
+
+        except Exception as e:
+            raise APIError(f"Failed to fetch ticker for {pair}: {e}") from e
+
+    def get_history(
+        self,
+        pair: str,
+        period: str = "1mo",
+        interval: str = "1d",
+        start: datetime | None = None,
+        end: datetime | None = None,
+    ) -> pd.DataFrame:
+        """
+        Get historical OHLC data for a crypto pair.
+
+        Args:
+            pair: Trading pair (e.g., "BTCTRY", "ETHTRY")
+            period: Data period (1d, 5d, 1mo, 3mo, 6mo, 1y)
+            interval: Data interval (1m, 5m, 15m, 30m, 1h, 4h, 1d, 1wk)
+            start: Start date
+            end: End date
+
+        Returns:
+            DataFrame with OHLCV data.
+        """
+        pair = pair.upper()
+
+        # Calculate time range
+        end_dt = end or datetime.now()
+        if start:
+            start_dt = start
+        else:
+            days = {"1d": 1, "5d": 5, "1mo": 30, "3mo": 90, "6mo": 180, "1y": 365}.get(period, 30)
+            start_dt = end_dt - timedelta(days=days)
+
+        from_ts = int(start_dt.timestamp())
+        to_ts = int(end_dt.timestamp())
+
+        cache_key = f"btcturk:history:{pair}:{interval}:{from_ts}:{to_ts}"
+        cached = self._cache_get(cache_key)
+        if cached is not None:
+            return cached
+
+        try:
+            # Get resolution in minutes
+            resolution = self.RESOLUTION_MAP.get(interval, 1440)
+
+            url = f"{self.GRAPH_API_URL}/v1/klines/history"
+            params = {
+                "symbol": pair,
+                "resolution": resolution,
+                "from": from_ts,
+                "to": to_ts,
+            }
+
+            response = self._client.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+
+            # Graph API returns TradingView format
+            status = data.get("s", "error")
+            if status != "ok":
+                raise DataNotAvailableError(f"No data available for {pair}")
+
+            # Parse TradingView format
+            timestamps = data.get("t", [])
+            opens = data.get("o", [])
+            highs = data.get("h", [])
+            lows = data.get("l", [])
+            closes = data.get("c", [])
+            volumes = data.get("v", [])
+
+            records = []
+            for i in range(len(timestamps)):
+                records.append(
+                    {
+                        "Date": datetime.fromtimestamp(timestamps[i]),
+                        "Open": float(opens[i]) if i < len(opens) else 0.0,
+                        "High": float(highs[i]) if i < len(highs) else 0.0,
+                        "Low": float(lows[i]) if i < len(lows) else 0.0,
+                        "Close": float(closes[i]) if i < len(closes) else 0.0,
+                        "Volume": float(volumes[i]) if i < len(volumes) else 0.0,
+                    }
+                )
+
+            df = pd.DataFrame(records)
+            if not df.empty:
+                df.set_index("Date", inplace=True)
+                df.sort_index(inplace=True)
+
+            self._cache_set(cache_key, df, TTL.OHLCV_HISTORY)
+            return df
+
+        except Exception as e:
+            raise APIError(f"Failed to fetch history for {pair}: {e}") from e
+
+    def get_pairs(self, quote: str = "TRY") -> list[str]:
+        """
+        Get list of available trading pairs.
+
+        Args:
+            quote: Quote currency filter (TRY, USDT, BTC)
+
+        Returns:
+            List of trading pair symbols.
+        """
+        cache_key = f"btcturk:pairs:{quote}"
+        cached = self._cache_get(cache_key)
+        if cached is not None:
+            return cached
+
+        try:
+            url = f"{self.BASE_URL}/ticker"
+            response = self._client.get(url)
+            response.raise_for_status()
+            data = response.json()
+
+            if not data.get("success", False):
+                return []
+
+            pairs = []
+            quote_upper = quote.upper()
+            for ticker in data.get("data", []):
+                pair = ticker.get("pair", "")
+                if pair.endswith(quote_upper):
+                    pairs.append(pair)
+
+            self._cache_set(cache_key, pairs, TTL.COMPANY_LIST)
+            return pairs
+
+        except Exception:
+            return []
+
+
+# Singleton
+_provider: BtcTurkProvider | None = None
+
+
+def get_btcturk_provider() -> BtcTurkProvider:
+    """Get singleton provider instance."""
+    global _provider
+    if _provider is None:
+        _provider = BtcTurkProvider()
+    return _provider

borsapy/_providers/dovizcom.py

@@ -0,0 +1,282 @@
+"""Doviz.com provider for forex and commodity data."""
+
+import re
+import time
+from datetime import datetime, timedelta
+from typing import Any
+
+import pandas as pd
+
+from borsapy._providers.base import BaseProvider
+from borsapy.cache import TTL
+from borsapy.exceptions import APIError, DataNotAvailableError
+
+
+class DovizcomProvider(BaseProvider):
+    """
+    Provider for forex and commodity data from doviz.com.
+
+    Supported assets:
+    - Currencies: USD, EUR, GBP, JPY, CHF, CAD, AUD
+    - Precious Metals: gram-altin, gumus, ons, XAG-USD, XPT-USD, XPD-USD
+    - Energy: BRENT, WTI
+    - Fuel: diesel, gasoline, lpg
+    """
+
+    BASE_URL = "https://api.doviz.com/api/v12"
+    TOKEN_EXPIRY = 3600  # 1 hour
+
+    FALLBACK_TOKEN = "3e75d7fabf1c50c8b962626dd0e5ea22d8000815e1b0920d0a26afd77fcd6609"
+
+    SUPPORTED_ASSETS = {
+        # Currencies
+        "USD",
+        "EUR",
+        "GBP",
+        "JPY",
+        "CHF",
+        "CAD",
+        "AUD",
+        # Precious Metals (TRY)
+        "gram-altin",
+        "gumus",
+        # Precious Metals (USD)
+        "ons",
+        "XAG-USD",
+        "XPT-USD",
+        "XPD-USD",
+        # Energy
+        "BRENT",
+        "WTI",
+        # Fuel
+        "diesel",
+        "gasoline",
+        "lpg",
+    }
+
+    FUEL_ASSETS = {"gasoline", "diesel", "lpg"}
+
+    def __init__(self):
+        super().__init__()
+        self._token: str | None = None
+        self._token_expiry: float = 0
+
+    def _get_token(self) -> str:
+        """Get valid Bearer token."""
+        if self._token and time.time() < self._token_expiry:
+            return self._token
+
+        # Try to extract token from website
+        try:
+            token = self._extract_token()
+            if token:
+                self._token = token
+                self._token_expiry = time.time() + self.TOKEN_EXPIRY
+                return token
+        except Exception:
+            pass
+
+        # Use fallback
+        return self.FALLBACK_TOKEN
+
+    def _extract_token(self) -> str | None:
+        """Extract token from doviz.com website."""
+        try:
+            response = self._client.get("https://www.doviz.com/")
+            html = response.text
+
+            # Look for 64-char hex token
+            patterns = [
+                r'token["\']?\s*:\s*["\']([a-f0-9]{64})["\']',
+                r"Bearer\s+([a-f0-9]{64})",
+            ]
+
+            for pattern in patterns:
+                match = re.search(pattern, html, re.IGNORECASE)
+                if match:
+                    return match.group(1)
+
+            return None
+        except Exception:
+            return None
+
+    def _get_headers(self, asset: str) -> dict[str, str]:
+        """Get request headers with token."""
+        if asset in ["gram-altin", "gumus", "ons"]:
+            origin = "https://altin.doviz.com"
+        else:
+            origin = "https://www.doviz.com"
+
+        token = self._get_token()
+
+        return {
+            "Accept": "*/*",
+            "Authorization": f"Bearer {token}",
+            "Origin": origin,
+            "Referer": f"{origin}/",
+            "User-Agent": self.DEFAULT_HEADERS["User-Agent"],
+        }
+
+    def get_current(self, asset: str) -> dict[str, Any]:
+        """
+        Get current price for an asset.
+
+        Args:
+            asset: Asset code (USD, EUR, gram-altin, BRENT, etc.)
+
+        Returns:
+            Dictionary with current price data.
+        """
+        asset = asset.upper() if asset.upper() in self.SUPPORTED_ASSETS else asset
+
+        if asset not in self.SUPPORTED_ASSETS:
+            raise DataNotAvailableError(
+                f"Unsupported asset: {asset}. Supported: {sorted(self.SUPPORTED_ASSETS)}"
+            )
+
+        cache_key = f"dovizcom:current:{asset}"
+        cached = self._cache_get(cache_key)
+        if cached:
+            return cached
+
+        try:
+            if asset in self.FUEL_ASSETS:
+                data = self._get_from_archive(asset, days=7)
+            else:
+                data = self._get_from_daily(asset)
+
+            if not data:
+                raise DataNotAvailableError(f"No data for {asset}")
+
+            result = {
+                "symbol": asset,
+                "last": float(data.get("close", 0)),
+                "open": float(data.get("open", 0)),
+                "high": float(data.get("highest", 0)),
+                "low": float(data.get("lowest", 0)),
+                "update_time": self._parse_timestamp(data.get("update_date")),
+            }
+
+            self._cache_set(cache_key, result, TTL.FX_RATES)
+            return result
+
+        except Exception as e:
+            raise APIError(f"Failed to fetch {asset}: {e}") from e
+
+    def get_history(
+        self,
+        asset: str,
+        period: str = "1mo",
+        start: datetime | None = None,
+        end: datetime | None = None,
+    ) -> pd.DataFrame:
+        """
+        Get historical data for an asset.
+
+        Args:
+            asset: Asset code.
+            period: Period (1d, 5d, 1mo, 3mo, 6mo, 1y).
+            start: Start date.
+            end: End date.
+
+        Returns:
+            DataFrame with OHLC data.
+        """
+        asset = asset.upper() if asset.upper() in self.SUPPORTED_ASSETS else asset
+
+        if asset not in self.SUPPORTED_ASSETS:
+            raise DataNotAvailableError(f"Unsupported asset: {asset}")
+
+        # Calculate date range
+        end_dt = end or datetime.now()
+        if start:
+            start_dt = start
+        else:
+            days = {"1d": 1, "5d": 5, "1mo": 30, "3mo": 90, "6mo": 180, "1y": 365}.get(period, 30)
+            start_dt = end_dt - timedelta(days=days)
+
+        cache_key = f"dovizcom:history:{asset}:{start_dt.date()}:{end_dt.date()}"
+        cached = self._cache_get(cache_key)
+        if cached is not None:
+            return cached
+
+        try:
+            url = f"{self.BASE_URL}/assets/{asset}/archive"
+            params = {
+                "start": int(start_dt.timestamp()),
+                "end": int(end_dt.timestamp()),
+            }
+
+            response = self._client.get(url, headers=self._get_headers(asset), params=params)
+            response.raise_for_status()
+            data = response.json()
+
+            archive = data.get("data", {}).get("archive", [])
+
+            records = []
+            for item in archive:
+                records.append(
+                    {
+                        "Date": self._parse_timestamp(item.get("update_date")),
+                        "Open": float(item.get("open", 0)),
+                        "High": float(item.get("highest", 0)),
+                        "Low": float(item.get("lowest", 0)),
+                        "Close": float(item.get("close", 0)),
+                    }
+                )
+
+            df = pd.DataFrame(records)
+            if not df.empty:
+                df.set_index("Date", inplace=True)
+                df.sort_index(inplace=True)
+
+            self._cache_set(cache_key, df, TTL.OHLCV_HISTORY)
+            return df
+
+        except Exception as e:
+            raise APIError(f"Failed to fetch history for {asset}: {e}") from e
+
+    def _get_from_daily(self, asset: str) -> dict | None:
+        """Get latest data from daily endpoint."""
+        url = f"{self.BASE_URL}/assets/{asset}/daily"
+        response = self._client.get(url, headers=self._get_headers(asset), params={"limit": 1})
+        response.raise_for_status()
+        data = response.json()
+
+        archive = data.get("data", {}).get("archive", [])
+        return archive[0] if archive else None
+
+    def _get_from_archive(self, asset: str, days: int = 7) -> dict | None:
+        """Get latest data from archive endpoint."""
+        end_time = int(time.time())
+        start_time = end_time - (days * 86400)
+
+        url = f"{self.BASE_URL}/assets/{asset}/archive"
+        params = {"start": start_time, "end": end_time}
+
+        response = self._client.get(url, headers=self._get_headers(asset), params=params)
+        response.raise_for_status()
+        data = response.json()
+
+        archive = data.get("data", {}).get("archive", [])
+        return archive[-1] if archive else None
+
+    def _parse_timestamp(self, ts: Any) -> datetime:
+        """Parse timestamp to datetime."""
+        if isinstance(ts, (int, float)):
+            return datetime.fromtimestamp(ts)
+        if isinstance(ts, datetime):
+            return ts
+        return datetime.now()
+
+
+# Singleton
+_provider: DovizcomProvider | None = None
+
+
+def get_dovizcom_provider() -> DovizcomProvider:
+    """Get singleton provider instance."""
+    global _provider
+    if _provider is None:
+        _provider = DovizcomProvider()
+    return _provider