openstockapi 0.1.0__py3-none-any.whl

openstockapi/__init__.py

@@ -0,0 +1,32 @@
+__version__ = "0.1.0"
+
+from openstockapi.api.stock import ohlcv, profile, quote, async_ohlcv
+from openstockapi.api.financial import income_statement, balance_sheet, cashflow, ratios
+from openstockapi.api.trading import foreign, insider, prop_trade
+from openstockapi.api.orderbook import bid_ask, depth
+from openstockapi.api.macro import indicators
+from openstockapi.api.fund import details as fund_details
+from openstockapi.api.news import news as company_news, events as company_events
+
+from openstockapi.core import exceptions
+from openstockapi.license import session
+
+__all__ = [
+    "ohlcv",
+    "async_ohlcv",
+    "profile",
+    "quote",
+    "income_statement",
+    "balance_sheet",
+    "cashflow",
+    "ratios",
+    "foreign",
+    "insider",
+    "prop_trade",
+    "bid_ask",
+    "depth",
+    "indicators",
+    "fund_details",
+    "company_news",
+    "company_events",
+]

openstockapi/api/financial.py

@@ -0,0 +1,48 @@
+from typing import List, Optional, Union, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.core.utils import clean_symbol
+from openstockapi.config.settings import DEFAULT_PROVIDER_PRIORITY
+from openstockapi.providers import get_provider
+from openstockapi.core.exceptions import ProviderUnavailableError
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+def _fetch_financial(symbol: str, stmt_type: str, period: str, provider: Optional[str]) -> Union[List[dict], Any]:
+    enforce_tier_and_rate_limit(DataTier.FREE, f"financial.{stmt_type}")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("financials", ["mas"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            reports = p_inst.get_financial_statements(symbol, stmt_type, period)
+            data_list = [rep.model_dump() for rep in reports]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+
+    raise ProviderUnavailableError(f"No provider succeeded in fetching financial statement '{stmt_type}' for '{symbol}': {last_err}")
+
+def income_statement(symbol: str, period: str = "Q", provider: Optional[str] = None) -> Union[List[dict], Any]:
+    return _fetch_financial(symbol, "income", period, provider)
+
+def balance_sheet(symbol: str, period: str = "Q", provider: Optional[str] = None) -> Union[List[dict], Any]:
+    return _fetch_financial(symbol, "balance", period, provider)
+
+def cashflow(symbol: str, period: str = "Q", provider: Optional[str] = None) -> Union[List[dict], Any]:
+    return _fetch_financial(symbol, "cashflow", period, provider)
+
+def ratios(symbol: str, period: str = "Q", provider: Optional[str] = None) -> Union[List[dict], Any]:
+    return _fetch_financial(symbol, "ratios", period, provider)

openstockapi/api/fund.py

@@ -0,0 +1,32 @@
+from typing import Optional, Union, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.config.settings import DEFAULT_PROVIDER_PRIORITY
+from openstockapi.providers import get_provider
+from openstockapi.core.exceptions import ProviderUnavailableError
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+def details(fund_id: int, provider: Optional[str] = None) -> Union[dict, Any]:
+    # Mutual fund data is a FREE endpoint
+    enforce_tier_and_rate_limit(DataTier.FREE, "fund.details")
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("fund", ["fmarket"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            fund_data = p_inst.get_fund_details(fund_id)
+            return fund_data.model_dump()
+        except Exception as e:
+            last_err = e
+            continue
+            
+    raise ProviderUnavailableError(f"No provider succeeded in fetching details for fund_id '{fund_id}': {last_err}")

openstockapi/api/macro.py

@@ -0,0 +1,35 @@
+from typing import List, Optional, Union, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.config.settings import DEFAULT_PROVIDER_PRIORITY
+from openstockapi.providers import get_provider
+from openstockapi.core.exceptions import ProviderUnavailableError
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+def indicators(provider: Optional[str] = None) -> Union[List[dict], Any]:
+    # Macro indicators is a FREE endpoint
+    enforce_tier_and_rate_limit(DataTier.FREE, "macro.indicators")
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("macro", ["mbk"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            records = p_inst.get_macro_indicators()
+            data_list = [rec.model_dump() for rec in records]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+            
+    raise ProviderUnavailableError(f"No provider succeeded in fetching macro indicators: {last_err}")

openstockapi/api/news.py

@@ -0,0 +1,60 @@
+from typing import List, Optional, Union, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.core.utils import clean_symbol
+from openstockapi.config.settings import DEFAULT_PROVIDER_PRIORITY
+from openstockapi.providers import get_provider
+from openstockapi.core.exceptions import ProviderUnavailableError
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+def news(symbol: str, limit: int = 10, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    # News is a FREE endpoint
+    enforce_tier_and_rate_limit(DataTier.FREE, "news")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("news", ["kbs"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            items = p_inst.get_company_news(symbol, limit)
+            data_list = [item.model_dump() for item in items]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+            
+    raise ProviderUnavailableError(f"No provider succeeded in fetching news for symbol '{symbol}': {last_err}")
+
+def events(symbol: str, limit: int = 10, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    enforce_tier_and_rate_limit(DataTier.FREE, "events")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("news", ["kbs"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            items = p_inst.get_company_events(symbol, limit)
+            data_list = [item.model_dump() for item in items]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+            
+    raise ProviderUnavailableError(f"No provider succeeded in fetching events for symbol '{symbol}': {last_err}")

openstockapi/api/orderbook.py

@@ -0,0 +1,15 @@
+from typing import Optional, Union, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.core.utils import clean_symbol
+
+def bid_ask(symbol: str) -> Union[dict, Any]:
+    # PRO or PREMIUM Tier required
+    enforce_tier_and_rate_limit(DataTier.PRO, "orderbook.bid_ask")
+    symbol = clean_symbol(symbol)
+    raise NotImplementedError("Real-time Order Book APIs are premium only.")
+
+def depth(symbol: str) -> Union[dict, Any]:
+    enforce_tier_and_rate_limit(DataTier.PRO, "orderbook.depth")
+    symbol = clean_symbol(symbol)
+    raise NotImplementedError("Real-time Order Book Depth APIs are premium only.")

openstockapi/api/stock.py

@@ -0,0 +1,116 @@
+from typing import List, Union, Optional, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.core.utils import clean_symbol
+from openstockapi.config.settings import DEFAULT_PROVIDER_PRIORITY
+from openstockapi.providers import get_provider
+from openstockapi.core.exceptions import ProviderUnavailableError
+from openstockapi.core.models import OHLCVBar, CompanyProfile, RealtimeQuote
+
+# Optional import for Pandas support
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+def ohlcv(symbol: str, resolution: str = "1D", start: Optional[str] = None, end: Optional[str] = None, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    # 1. Enforce safety checks
+    enforce_tier_and_rate_limit(DataTier.FREE, "stock.ohlcv")
+
+    # 2. Standardize inputs
+    symbol = clean_symbol(symbol)
+    if start is None:
+        start = "2020-01-01"
+    if end is None:
+        import datetime
+        end = datetime.datetime.now().strftime("%Y-%m-%d")
+
+    # 3. Resolve provider priority list
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("ohlcv", ["dnse"])
+
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            bars = p_inst.get_ohlcv(symbol, resolution, start, end)
+            data_list = [bar.model_dump() for bar in bars]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+
+    raise ProviderUnavailableError(f"No provider succeeded in fetching OHLCV for '{symbol}': {last_err}")
+
+async def async_ohlcv(symbol: str, resolution: str = "1D", start: Optional[str] = None, end: Optional[str] = None, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    enforce_tier_and_rate_limit(DataTier.FREE, "stock.ohlcv")
+    symbol = clean_symbol(symbol)
+    if start is None:
+        start = "2020-01-01"
+    if end is None:
+        import datetime
+        end = datetime.datetime.now().strftime("%Y-%m-%d")
+
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("ohlcv", ["dnse"])
+
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            bars = await p_inst.async_get_ohlcv(symbol, resolution, start, end)
+            data_list = [bar.model_dump() for bar in bars]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+
+    raise ProviderUnavailableError(f"No provider succeeded in fetching async OHLCV for '{symbol}': {last_err}")
+
+def profile(symbol: str, provider: Optional[str] = None) -> Union[dict, Any]:
+    enforce_tier_and_rate_limit(DataTier.FREE, "stock.profile")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("profile", ["vndirect"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            prof = p_inst.get_company_profile(symbol)
+            return prof.model_dump()
+        except Exception as e:
+            last_err = e
+            continue
+
+    raise ProviderUnavailableError(f"No provider succeeded in fetching profile for '{symbol}': {last_err}")
+
+def quote(symbol: str, provider: Optional[str] = None) -> Union[dict, Any]:
+    # PREMIUM / PRO Tier endpoint
+    enforce_tier_and_rate_limit(DataTier.PRO, "stock.quote")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("quote", ["dnse"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            q = p_inst.get_realtime_quote(symbol)
+            return q.model_dump()
+        except Exception as e:
+            last_err = e
+            continue
+
+    raise ProviderUnavailableError(f"No provider succeeded in fetching quote for '{symbol}': {last_err}")

openstockapi/api/trading.py

@@ -0,0 +1,79 @@
+from typing import List, Optional, Union, Any
+from openstockapi.core.types import DataTier
+from openstockapi.core.security import enforce_tier_and_rate_limit
+from openstockapi.core.utils import clean_symbol
+from openstockapi.config.settings import DEFAULT_PROVIDER_PRIORITY
+from openstockapi.providers import get_provider
+from openstockapi.core.exceptions import ProviderUnavailableError
+
+try:
+    import pandas as pd
+    HAS_PANDAS = True
+except ImportError:
+    HAS_PANDAS = False
+
+def foreign(symbol: str, limit: int = 10, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    enforce_tier_and_rate_limit(DataTier.PRO, "trading.foreign")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("trading", ["vci"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            records = p_inst.get_foreign_trading(symbol, limit)
+            data_list = [rec.model_dump() for rec in records]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+    raise ProviderUnavailableError(f"No provider succeeded in fetching foreign trading for '{symbol}': {last_err}")
+
+def insider(symbol: str, limit: int = 10, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    enforce_tier_and_rate_limit(DataTier.PRO, "trading.insider")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("trading", ["vci"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            records = p_inst.get_insider_trading(symbol, limit)
+            data_list = [rec.model_dump() for rec in records]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+    raise ProviderUnavailableError(f"No provider succeeded in fetching insider transactions for '{symbol}': {last_err}")
+
+def prop_trade(symbol: str, limit: int = 10, provider: Optional[str] = None) -> Union[List[dict], Any]:
+    enforce_tier_and_rate_limit(DataTier.PRO, "trading.prop_trade")
+    symbol = clean_symbol(symbol)
+    
+    providers_to_try = [provider] if provider else DEFAULT_PROVIDER_PRIORITY.get("trading", ["vci"])
+    
+    last_err = None
+    for p_name in providers_to_try:
+        p_inst = get_provider(p_name)
+        if not p_inst:
+            continue
+        try:
+            records = p_inst.get_prop_trading(symbol, limit)
+            data_list = [rec.model_dump() for rec in records]
+            if HAS_PANDAS:
+                return pd.DataFrame(data_list)
+            return data_list
+        except Exception as e:
+            last_err = e
+            continue
+    raise ProviderUnavailableError(f"No provider succeeded in fetching proprietary trading for '{symbol}': {last_err}")

openstockapi/config/settings.py

@@ -0,0 +1,13 @@
+from typing import Dict, List
+
+DEFAULT_PROVIDER_PRIORITY: Dict[str, List[str]] = {
+    "ohlcv": ["dnse"],
+    "financials": ["mas"],
+    "profile": ["vndirect"],
+    "quote": ["dnse", "vci"],
+    "orderbook": ["vci", "dnse"],
+    "trading": ["vci"],
+    "macro": ["mbk"],
+    "fund": ["fmarket"],
+    "news": ["kbs"],
+}

openstockapi/core/base_provider.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+from openstockapi.core.types import DataTier
+from openstockapi.core.models import OHLCVBar, FinancialItem, CompanyProfile, RealtimeQuote, OrderBook
+
+from openstockapi.core.models_trading import ForeignTradingEntry, PropTradingEntry, InsiderTradingEntry
+
+class BaseProvider(ABC):
+    name: str = "base"
+    required_tier: DataTier = DataTier.FREE
+
+    @abstractmethod
+    def get_ohlcv(self, symbol: str, resolution: str, from_date: str, to_date: str) -> List[OHLCVBar]:
+        pass
+
+    @abstractmethod
+    def get_financial_statements(self, symbol: str, stmt_type: str, period: str) -> List[FinancialItem]:
+        pass
+
+    def get_company_profile(self, symbol: str) -> CompanyProfile:
+        raise NotImplementedError("This provider does not support company profiles")
+
+    def get_realtime_quote(self, symbol: str) -> RealtimeQuote:
+        raise NotImplementedError("This provider does not support realtime quotes")
+
+    def get_order_book(self, symbol: str) -> OrderBook:
+        raise NotImplementedError("This provider does not support order book depth")
+
+    def get_foreign_trading(self, symbol: str, limit: int = 10) -> List[ForeignTradingEntry]:
+        raise NotImplementedError("This provider does not support foreign trading data")
+
+    def get_prop_trading(self, symbol: str, limit: int = 10) -> List[PropTradingEntry]:
+        raise NotImplementedError("This provider does not support proprietary trading data")
+
+    def get_insider_trading(self, symbol: str, limit: int = 10) -> List[InsiderTradingEntry]:
+        raise NotImplementedError("This provider does not support insider trading transactions")
+
+    def get_macro_indicators(self) -> List[Any]:
+        raise NotImplementedError("This provider does not support macro indicators")
+
+    def get_fund_details(self, fund_id: int) -> Any:
+        raise NotImplementedError("This provider does not support fund details data")
+
+    def get_company_news(self, symbol: str, limit: int = 10) -> List[Any]:
+        raise NotImplementedError("This provider does not support company news data")
+
+    def get_company_events(self, symbol: str, limit: int = 10) -> List[Any]:
+        raise NotImplementedError("This provider does not support company events data")
+
+    async def async_get_ohlcv(self, symbol: str, resolution: str, from_date: str, to_date: str) -> List[OHLCVBar]:
+        raise NotImplementedError("This provider does not support async OHLCV")
+
+    async def async_get_financial_statements(self, symbol: str, stmt_type: str, period: str) -> List[FinancialItem]:
+        raise NotImplementedError("This provider does not support async financial statements")

openstockapi/core/exceptions.py

@@ -0,0 +1,29 @@
+class OpenStockAPIError(Exception):
+    """Base exception for all OpenStockAPI errors."""
+    pass
+
+class ProviderUnavailableError(OpenStockAPIError):
+    """Raised when a data provider is down or fails to respond."""
+    pass
+
+class RateLimitError(OpenStockAPIError):
+    """Raised when the rate limit for the tier is exceeded."""
+    pass
+
+class SymbolNotFoundError(OpenStockAPIError):
+    """Raised when a ticker symbol is not found."""
+    pass
+
+class DataParseError(OpenStockAPIError):
+    """Raised when parsing data from provider fails."""
+    pass
+
+class TierUpgradeRequiredError(OpenStockAPIError):
+    """Raised when a free user calls a paid endpoint."""
+    def __init__(self, required_tier: str, endpoint: str):
+        self.required_tier = required_tier
+        self.endpoint = endpoint
+        super().__init__(
+            f"Endpoint '{endpoint}' requires '{required_tier}' tier or above. "
+            f"Please upgrade your tier to access this data."
+        )

openstockapi/core/http_client.py

@@ -0,0 +1,62 @@
+import httpx
+import random
+import time
+from typing import Any, Dict, Optional
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0",
+]
+
+class RobustHTTPClient:
+    def __init__(self) -> None:
+        self.client = httpx.Client(
+            timeout=httpx.Timeout(15.0, connect=5.0),
+            follow_redirects=True
+        )
+        self.async_client = httpx.AsyncClient(
+            timeout=httpx.Timeout(15.0, connect=5.0),
+            follow_redirects=True
+        )
+
+    def request(self, method: str, url: str, retries: int = 3, backoff_factor: float = 0.5, **kwargs: Any) -> httpx.Response:
+        headers = kwargs.get("headers", {})
+        if "User-Agent" not in headers:
+            headers["User-Agent"] = random.choice(USER_AGENTS)
+        kwargs["headers"] = headers
+
+        last_err = None
+        for attempt in range(retries):
+            try:
+                response = self.client.request(method, url, **kwargs)
+                response.raise_for_status()
+                return response
+            except (httpx.HTTPError, httpx.NetworkError) as e:
+                last_err = e
+                if attempt < retries - 1:
+                    time.sleep(backoff_factor * (2 ** attempt))
+                    continue
+        raise last_err or httpx.HTTPError("Request failed after retries")
+
+    async def async_request(self, method: str, url: str, retries: int = 3, backoff_factor: float = 0.5, **kwargs: Any) -> httpx.Response:
+        import asyncio
+        headers = kwargs.get("headers", {})
+        if "User-Agent" not in headers:
+            headers["User-Agent"] = random.choice(USER_AGENTS)
+        kwargs["headers"] = headers
+
+        last_err = None
+        for attempt in range(retries):
+            try:
+                response = await self.async_client.request(method, url, **kwargs)
+                response.raise_for_status()
+                return response
+            except (httpx.HTTPError, httpx.NetworkError) as e:
+                last_err = e
+                if attempt < retries - 1:
+                    await asyncio.sleep(backoff_factor * (2 ** attempt))
+                    continue
+        raise last_err or httpx.HTTPError("Async request failed after retries")
+
+http_client = RobustHTTPClient()

openstockapi/core/models.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+from pydantic import BaseModel
+from typing import Dict, List, Optional, Any
+
+class OHLCVBar(BaseModel):
+    symbol: str
+    timestamp: datetime
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int
+    provider: str
+
+class FinancialItem(BaseModel):
+    symbol: str
+    year: int
+    quarter: Optional[int] = None
+    statement_type: str  # "income", "balance", "cashflow", "ratios"
+    items: Dict[str, Optional[float]]
+    provider: str
+
+class CompanyProfile(BaseModel):
+    symbol: str
+    full_name: str
+    en_name: Optional[str] = None
+    exchange: str
+    industry: Optional[str] = None
+    website: Optional[str] = None
+    employees: Optional[int] = None
+    description: Optional[str] = None
+    provider: str
+
+class RealtimeQuote(BaseModel):
+    symbol: str
+    price: float
+    change: float
+    pct_change: float
+    volume: int
+    timestamp: datetime
+    provider: str
+
+class OrderBookEntry(BaseModel):
+    price: float
+    volume: int
+
+class OrderBook(BaseModel):
+    symbol: str
+    bids: List[OrderBookEntry]
+    asks: List[OrderBookEntry]
+    timestamp: datetime
+    provider: str
+
+class NewsItem(BaseModel):
+    symbol: str
+    title: str
+    url: Optional[str] = None
+    source: Optional[str] = None
+    publish_date: datetime
+    summary: Optional[str] = None
+    provider: str
+
+class FundItem(BaseModel):
+    fund_code: str
+    name: str
+    nav: float
+    provider: str

openstockapi/core/models_fund.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class FundHolding(BaseModel):
+    ticker: str
+    name: Optional[str] = None
+    net_asset_percent: float
+    asset_value: Optional[float] = None
+    volume: Optional[float] = None
+
+class FundDetails(BaseModel):
+    fund_id: int
+    name: str
+    short_name: str
+    code: str
+    price: float
+    nav: float
+    expected_return: Optional[float] = None
+    management_fee: Optional[float] = None
+    description: Optional[str] = None
+    holdings: List[FundHolding]
+    provider: str