469class Ticker(TechnicalMixin, TwitterMixin):
 470    """
 471    A yfinance-like interface for Turkish stock data.
 472
 473    Examples:
 474        >>> import borsapy as bp
 475        >>> stock = bp.Ticker("THYAO")
 476        >>> stock.info
 477        {'symbol': 'THYAO', 'last': 268.5, ...}
 478        >>> stock.history(period="1mo")
 479                         Open    High     Low   Close    Volume
 480        Date
 481        2024-12-01    265.00  268.00  264.00  267.50  12345678
 482        ...
 483    """
 484
 485    def __init__(self, symbol: str):
 486        """
 487        Initialize a Ticker object.
 488
 489        Args:
 490            symbol: Stock symbol (e.g., "THYAO", "GARAN", "ASELS").
 491                    The ".IS" or ".E" suffix is optional and will be removed.
 492        """
 493        self._symbol = symbol.upper().replace(".IS", "").replace(".E", "")
 494        self._tradingview = get_tradingview_provider()
 495        self._isyatirim = None  # Lazy load for financial statements
 496        self._kap = None  # Lazy load for KAP disclosures
 497        self._isin_provider = None  # Lazy load for ISIN lookup
 498        self._hedeffiyat = None  # Lazy load for analyst price targets
 499        self._etf_provider = None  # Lazy load for ETF holders
 500
 501    def _get_tweet_query(self) -> str:
 502        return _build_stock_query(self._symbol)
 503
 504    def _get_isyatirim(self):
 505        """Lazy load İş Yatırım provider for financial statements."""
 506        if self._isyatirim is None:
 507            from borsapy._providers.isyatirim import get_isyatirim_provider
 508
 509            self._isyatirim = get_isyatirim_provider()
 510        return self._isyatirim
 511
 512    def _get_kap(self):
 513        """Lazy load KAP provider for disclosures and calendar."""
 514        if self._kap is None:
 515            from borsapy._providers.kap import get_kap_provider
 516
 517            self._kap = get_kap_provider()
 518        return self._kap
 519
 520    def _get_isin_provider(self):
 521        """Lazy load ISIN provider."""
 522        if self._isin_provider is None:
 523            from borsapy._providers.isin import get_isin_provider
 524
 525            self._isin_provider = get_isin_provider()
 526        return self._isin_provider
 527
 528    def _get_hedeffiyat(self):
 529        """Lazy load hedeffiyat.com.tr provider for analyst price targets."""
 530        if self._hedeffiyat is None:
 531            from borsapy._providers.hedeffiyat import get_hedeffiyat_provider
 532
 533            self._hedeffiyat = get_hedeffiyat_provider()
 534        return self._hedeffiyat
 535
 536    def _get_etf_provider(self):
 537        """Lazy load TradingView ETF provider for ETF holders."""
 538        if self._etf_provider is None:
 539            from borsapy._providers.tradingview_etf import get_tradingview_etf_provider
 540
 541            self._etf_provider = get_tradingview_etf_provider()
 542        return self._etf_provider
 543
 544    @property
 545    def symbol(self) -> str:
 546        """Return the ticker symbol."""
 547        return self._symbol
 548
 549    @property
 550    def fast_info(self) -> FastInfo:
 551        """
 552        Get fast access to common ticker information.
 553
 554        Returns a FastInfo object with quick access to frequently used data:
 555        - currency, exchange, timezone
 556        - last_price, open, day_high, day_low, previous_close, volume
 557        - market_cap, shares, pe_ratio, pb_ratio
 558        - year_high, year_low (52-week)
 559        - fifty_day_average, two_hundred_day_average
 560        - free_float, foreign_ratio
 561
 562        Examples:
 563            >>> stock = Ticker("THYAO")
 564            >>> stock.fast_info.market_cap
 565            370530000000
 566            >>> stock.fast_info['pe_ratio']
 567            2.8
 568            >>> stock.fast_info.keys()
 569            ['currency', 'exchange', 'timezone', ...]
 570        """
 571        if not hasattr(self, "_fast_info"):
 572            self._fast_info = FastInfo(self)
 573        return self._fast_info
 574
 575    @property
 576    def info(self) -> EnrichedInfo:
 577        """
 578        Get comprehensive ticker information with yfinance-compatible fields.
 579
 580        Returns:
 581            EnrichedInfo object providing dict-like access to:
 582
 583            Basic fields (always loaded, fast):
 584            - symbol, last, open, high, low, close, volume
 585            - change, change_percent, update_time
 586
 587            yfinance aliases (map to basic fields):
 588            - regularMarketPrice, currentPrice -> last
 589            - regularMarketOpen -> open
 590            - regularMarketDayHigh -> high
 591            - regularMarketDayLow -> low
 592            - regularMarketPreviousClose -> close
 593            - regularMarketVolume -> volume
 594
 595            Extended fields (lazy-loaded on access):
 596            - marketCap, trailingPE, priceToBook, enterpriseToEbitda
 597            - sharesOutstanding, fiftyTwoWeekHigh, fiftyTwoWeekLow
 598            - fiftyDayAverage, twoHundredDayAverage
 599            - floatShares, foreignRatio, netDebt
 600            - currency, exchange, timezone
 601
 602            Dividend fields (lazy-loaded on access):
 603            - dividendYield, exDividendDate
 604            - trailingAnnualDividendRate, trailingAnnualDividendYield
 605
 606        Examples:
 607            >>> stock = Ticker("THYAO")
 608            >>> stock.info['last']  # Basic field - fast
 609            268.5
 610            >>> stock.info['marketCap']  # Extended field - fetches İş Yatırım
 611            370530000000
 612            >>> stock.info['trailingPE']  # yfinance compatible name
 613            2.8
 614            >>> stock.info.get('dividendYield')  # Safe access
 615            1.28
 616            >>> stock.info.todict()  # Get all as regular dict
 617            {...}
 618        """
 619        if not hasattr(self, "_enriched_info"):
 620            self._enriched_info = EnrichedInfo(self)
 621        return self._enriched_info
 622
 623    def history(
 624        self,
 625        period: str = "1mo",
 626        interval: str = "1d",
 627        start: datetime | str | None = None,
 628        end: datetime | str | None = None,
 629        actions: bool = False,
 630        adjust: bool = True,
 631    ) -> pd.DataFrame:
 632        """
 633        Get historical OHLCV data.
 634
 635        Args:
 636            period: How much data to fetch. Valid periods:
 637                    1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max.
 638                    Ignored if start is provided.
 639            interval: Data granularity. Valid intervals:
 640                      1m, 5m, 15m, 30m, 1h, 1d, 1wk, 1mo.
 641            start: Start date (string or datetime).
 642            end: End date (string or datetime). Defaults to today.
 643            actions: If True, include Dividends and Stock Splits columns.
 644                     Defaults to False.
 645            adjust: If True (default), return split-adjusted prices.
 646                    If False, return unadjusted (raw) prices.
 647
 648        Returns:
 649            DataFrame with columns: Open, High, Low, Close, Volume.
 650            If actions=True, also includes Dividends and Stock Splits columns.
 651            Index is the Date.
 652
 653        Examples:
 654            >>> stock = Ticker("THYAO")
 655            >>> stock.history(period="1mo")  # Last month
 656            >>> stock.history(period="1y", interval="1wk")  # Weekly for 1 year
 657            >>> stock.history(start="2024-01-01", end="2024-06-30")  # Date range
 658            >>> stock.history(period="1y", actions=True)  # With dividends/splits
 659            >>> stock.history(period="max", adjust=False)  # Raw unadjusted prices
 660        """
 661        # Parse dates if strings
 662        start_dt = self._parse_date(start) if start else None
 663        end_dt = self._parse_date(end) if end else None
 664
 665        df = self._tradingview.get_history(
 666            symbol=self._symbol,
 667            period=period,
 668            interval=interval,
 669            start=start_dt,
 670            end=end_dt,
 671        )
 672
 673        if not adjust and not df.empty:
 674            df = self._unadjust_prices(df)
 675
 676        if actions and not df.empty:
 677            df = self._add_actions_to_history(df)
 678
 679        return df
 680
 681    def _add_actions_to_history(self, df: pd.DataFrame) -> pd.DataFrame:
 682        """
 683        Add Dividends and Stock Splits columns to historical data.
 684
 685        Args:
 686            df: Historical OHLCV DataFrame.
 687
 688        Returns:
 689            DataFrame with added Dividends and Stock Splits columns.
 690        """
 691        # Initialize columns with zeros
 692        df = df.copy()
 693        df["Dividends"] = 0.0
 694        df["Stock Splits"] = 0.0
 695
 696        # Get dividends
 697        try:
 698            divs = self.dividends
 699            if not divs.empty:
 700                for div_date, row in divs.iterrows():
 701                    # Use date() for timezone-agnostic comparison
 702                    div_date_only = pd.Timestamp(div_date).date()
 703                    for idx in df.index:
 704                        idx_date_only = pd.Timestamp(idx).date()
 705                        if div_date_only == idx_date_only:
 706                            df.loc[idx, "Dividends"] = row.get("Amount", 0)
 707                            break
 708        except Exception:
 709            pass
 710
 711        # Get stock splits (capital increases)
 712        try:
 713            splits = self.splits
 714            if not splits.empty:
 715                for split_date, row in splits.iterrows():
 716                    # Use date() for timezone-agnostic comparison
 717                    split_date_only = pd.Timestamp(split_date).date()
 718                    # Calculate split ratio
 719                    # BonusFromCapital + BonusFromDividend = total bonus percentage
 720                    bonus_pct = row.get("BonusFromCapital", 0) + row.get(
 721                        "BonusFromDividend", 0
 722                    )
 723                    if bonus_pct > 0:
 724                        # Convert percentage to split ratio (e.g., 20% bonus = 1.2 split)
 725                        split_ratio = 1 + (bonus_pct / 100)
 726                        for idx in df.index:
 727                            idx_date_only = pd.Timestamp(idx).date()
 728                            if split_date_only == idx_date_only:
 729                                df.loc[idx, "Stock Splits"] = split_ratio
 730                                break
 731        except Exception:
 732            pass
 733
 734        return df
 735
 736    def _unadjust_prices(self, df: pd.DataFrame) -> pd.DataFrame:
 737        """
 738        Reverse split adjustments to return raw unadjusted prices.
 739
 740        TradingView returns split-adjusted prices by default. This method
 741        uses the splits data from İş Yatırım to reverse the adjustments.
 742        """
 743        try:
 744            splits = self.splits
 745        except Exception:
 746            return df
 747
 748        if splits.empty:
 749            return df
 750
 751        # Collect split events with bonus ratios
 752        split_events = []
 753        for split_date, row in splits.iterrows():
 754            bonus_pct = row.get("BonusFromCapital", 0) + row.get(
 755                "BonusFromDividend", 0
 756            )
 757            if bonus_pct > 0:
 758                ratio = 1 + (bonus_pct / 100)
 759                split_events.append(
 760                    (pd.Timestamp(split_date, tz="Europe/Istanbul"), ratio)
 761                )
 762
 763        if not split_events:
 764            return df
 765
 766        # Sort by date ascending
 767        split_events.sort(key=lambda x: x[0])
 768
 769        df = df.copy()
 770
 771        # Build a vectorized adjustment factor series.
 772        # For each split, all rows BEFORE the split date get multiplied by the ratio.
 773        factor = pd.Series(1.0, index=df.index)
 774        for split_date, ratio in split_events:
 775            factor = factor * pd.Series(
 776                [ratio if idx < split_date else 1.0 for idx in df.index],
 777                index=df.index,
 778            )
 779
 780        price_cols = [c for c in ["Open", "High", "Low", "Close"] if c in df.columns]
 781        for col in price_cols:
 782            df[col] = df[col] * factor
 783        if "Volume" in df.columns:
 784            df["Volume"] = df["Volume"] / factor
 785
 786        return df
 787
 788    @cached_property
 789    def dividends(self) -> pd.DataFrame:
 790        """
 791        Get dividend history.
 792
 793        Returns:
 794            DataFrame with dividend history:
 795            - Amount: Dividend per share (TL)
 796            - GrossRate: Gross dividend rate (%)
 797            - NetRate: Net dividend rate (%)
 798            - TotalDividend: Total dividend distributed (TL)
 799
 800        Examples:
 801            >>> stock = Ticker("THYAO")
 802            >>> stock.dividends
 803                           Amount  GrossRate  NetRate  TotalDividend
 804            Date
 805            2025-09-02     3.442    344.20   292.57  4750000000.0
 806            2025-06-16     3.442    344.20   292.57  4750000000.0
 807        """
 808        return self._get_isyatirim().get_dividends(self._symbol)
 809
 810    @cached_property
 811    def splits(self) -> pd.DataFrame:
 812        """
 813        Get capital increase (split) history.
 814
 815        Note: Turkish market uses capital increases instead of traditional splits.
 816        - RightsIssue: Paid capital increase (bedelli)
 817        - BonusFromCapital: Free shares from capital reserves (bedelsiz iç kaynak)
 818        - BonusFromDividend: Free shares from dividend (bedelsiz temettüden)
 819
 820        Returns:
 821            DataFrame with capital increase history:
 822            - Capital: New capital after increase (TL)
 823            - RightsIssue: Rights issue rate (%)
 824            - BonusFromCapital: Bonus from capital (%)
 825            - BonusFromDividend: Bonus from dividend (%)
 826
 827        Examples:
 828            >>> stock = Ticker("THYAO")
 829            >>> stock.splits
 830                             Capital  RightsIssue  BonusFromCapital  BonusFromDividend
 831            Date
 832            2013-06-26  1380000000.0         0.0             15.00               0.0
 833            2011-07-11  1200000000.0         0.0              0.00              20.0
 834        """
 835        return self._get_isyatirim().get_capital_increases(self._symbol)
 836
 837    @cached_property
 838    def actions(self) -> pd.DataFrame:
 839        """
 840        Get combined dividends and splits history.
 841
 842        Returns:
 843            DataFrame with combined dividend and split actions:
 844            - Dividends: Dividend per share (TL) or 0
 845            - Splits: Combined split ratio (0 if no split)
 846
 847        Examples:
 848            >>> stock = Ticker("THYAO")
 849            >>> stock.actions
 850                         Dividends  Splits
 851            Date
 852            2025-09-02      3.442    0.0
 853            2013-06-26      0.000   15.0
 854        """
 855        dividends = self.dividends
 856        splits = self.splits
 857
 858        # Merge on index (Date)
 859        if dividends.empty and splits.empty:
 860            return pd.DataFrame(columns=["Dividends", "Splits"])
 861
 862        # Extract relevant columns
 863        div_series = dividends["Amount"] if not dividends.empty else pd.Series(dtype=float)
 864        split_series = (
 865            splits["BonusFromCapital"] + splits["BonusFromDividend"]
 866            if not splits.empty
 867            else pd.Series(dtype=float)
 868        )
 869
 870        # Combine into single DataFrame
 871        result = pd.DataFrame({"Dividends": div_series, "Splits": split_series})
 872        result = result.fillna(0)
 873        result = result.sort_index(ascending=False)
 874
 875        return result
 876
 877    def get_balance_sheet(
 878        self,
 879        quarterly: bool = False,
 880        financial_group: str | None = None,
 881        last_n: int | str | None = None,
 882    ) -> pd.DataFrame:
 883        """
 884        Get balance sheet data.
 885
 886        Args:
 887            quarterly: If True, return quarterly data. If False, return annual.
 888            financial_group: Financial group code. Use "UFRS" for banks,
 889                           "XI_29" for industrial companies. If None, defaults to XI_29.
 890            last_n: Number of periods to fetch. None for default (5), int for exact
 891                    count (e.g. 10 = 10 annual periods), "all" for maximum available.
 892
 893        Returns:
 894            DataFrame with balance sheet items as rows and periods as columns.
 895
 896        Examples:
 897            >>> stock = bp.Ticker("THYAO")
 898            >>> stock.get_balance_sheet()  # Annual, industrial (5 periods)
 899            >>> stock.get_balance_sheet(quarterly=True, last_n=20)  # 20 quarters
 900
 901            >>> bank = bp.Ticker("AKBNK")
 902            >>> bank.get_balance_sheet(financial_group="UFRS", last_n="all")
 903        """
 904        return self._get_isyatirim().get_financial_statements(
 905            symbol=self._symbol,
 906            statement_type="balance_sheet",
 907            quarterly=quarterly,
 908            financial_group=financial_group,
 909            last_n=last_n,
 910        )
 911
 912    def get_income_stmt(
 913        self,
 914        quarterly: bool = False,
 915        financial_group: str | None = None,
 916        last_n: int | str | None = None,
 917    ) -> pd.DataFrame:
 918        """
 919        Get income statement data.
 920
 921        Args:
 922            quarterly: If True, return quarterly data. If False, return annual.
 923            financial_group: Financial group code. Use "UFRS" for banks,
 924                           "XI_29" for industrial companies. If None, defaults to XI_29.
 925            last_n: Number of periods to fetch. None for default (5), int for exact
 926                    count (e.g. 10 = 10 annual periods), "all" for maximum available.
 927
 928        Returns:
 929            DataFrame with income statement items as rows and periods as columns.
 930
 931        Examples:
 932            >>> stock = bp.Ticker("THYAO")
 933            >>> stock.get_income_stmt()  # Annual (5 periods)
 934            >>> stock.get_income_stmt(quarterly=True, last_n=20)  # 20 quarters
 935
 936            >>> bank = bp.Ticker("AKBNK")
 937            >>> bank.get_income_stmt(quarterly=True, financial_group="UFRS")
 938        """
 939        return self._get_isyatirim().get_financial_statements(
 940            symbol=self._symbol,
 941            statement_type="income_stmt",
 942            quarterly=quarterly,
 943            financial_group=financial_group,
 944            last_n=last_n,
 945        )
 946
 947    def get_cashflow(
 948        self,
 949        quarterly: bool = False,
 950        financial_group: str | None = None,
 951        last_n: int | str | None = None,
 952    ) -> pd.DataFrame:
 953        """
 954        Get cash flow statement data.
 955
 956        Args:
 957            quarterly: If True, return quarterly data. If False, return annual.
 958            financial_group: Financial group code. Use "UFRS" for banks,
 959                           "XI_29" for industrial companies. If None, defaults to XI_29.
 960            last_n: Number of periods to fetch. None for default (5), int for exact
 961                    count (e.g. 10 = 10 annual periods), "all" for maximum available.
 962
 963        Returns:
 964            DataFrame with cash flow items as rows and periods as columns.
 965
 966        Examples:
 967            >>> stock = bp.Ticker("THYAO")
 968            >>> stock.get_cashflow()  # Annual (5 periods)
 969            >>> stock.get_cashflow(quarterly=True, last_n=20)  # 20 quarters
 970
 971            >>> bank = bp.Ticker("AKBNK")
 972            >>> bank.get_cashflow(financial_group="UFRS", last_n="all")
 973        """
 974        return self._get_isyatirim().get_financial_statements(
 975            symbol=self._symbol,
 976            statement_type="cashflow",
 977            quarterly=quarterly,
 978            financial_group=financial_group,
 979            last_n=last_n,
 980        )
 981
 982    # Legacy property aliases for backward compatibility
 983    @cached_property
 984    def balance_sheet(self) -> pd.DataFrame:
 985        """Annual balance sheet (use get_balance_sheet() for more options)."""
 986        return self.get_balance_sheet(quarterly=False)
 987
 988    @cached_property
 989    def quarterly_balance_sheet(self) -> pd.DataFrame:
 990        """Quarterly balance sheet (use get_balance_sheet(quarterly=True) for more options)."""
 991        return self.get_balance_sheet(quarterly=True)
 992
 993    @cached_property
 994    def income_stmt(self) -> pd.DataFrame:
 995        """Annual income statement (use get_income_stmt() for more options)."""
 996        return self.get_income_stmt(quarterly=False)
 997
 998    @cached_property
 999    def quarterly_income_stmt(self) -> pd.DataFrame:
1000        """Quarterly income statement (use get_income_stmt(quarterly=True) for more options)."""
1001        return self.get_income_stmt(quarterly=True)
1002
1003    @cached_property
1004    def cashflow(self) -> pd.DataFrame:
1005        """Annual cash flow (use get_cashflow() for more options)."""
1006        return self.get_cashflow(quarterly=False)
1007
1008    @cached_property
1009    def quarterly_cashflow(self) -> pd.DataFrame:
1010        """Quarterly cash flow (use get_cashflow(quarterly=True) for more options)."""
1011        return self.get_cashflow(quarterly=True)
1012
1013    def _calculate_ttm(self, quarterly_df: pd.DataFrame) -> pd.DataFrame:
1014        """
1015        Calculate trailing twelve months (TTM) by summing last 4 quarters.
1016
1017        Args:
1018            quarterly_df: DataFrame with quarterly data (columns in YYYYQN format).
1019
1020        Returns:
1021            DataFrame with single TTM column containing summed values.
1022        """
1023        if quarterly_df.empty or len(quarterly_df.columns) < 4:
1024            return pd.DataFrame(columns=["TTM"])
1025
1026        # First 4 columns = last 4 quarters (most recent first)
1027        last_4_quarters = quarterly_df.iloc[:, :4]
1028
1029        # Convert to numeric, coercing errors to NaN
1030        numeric_df = last_4_quarters.apply(pd.to_numeric, errors="coerce")
1031
1032        return numeric_df.sum(axis=1).to_frame(name="TTM")
1033
1034    def get_ttm_income_stmt(self, financial_group: str | None = None) -> pd.DataFrame:
1035        """
1036        Get trailing twelve months (TTM) income statement.
1037
1038        Calculates TTM by summing the last 4 quarters of income statement data.
1039
1040        Args:
1041            financial_group: Financial group code. Use "UFRS" for banks,
1042                           "XI_29" for industrial companies. If None, defaults to XI_29.
1043
1044        Returns:
1045            DataFrame with TTM column containing summed values for each line item.
1046
1047        Examples:
1048            >>> stock = bp.Ticker("THYAO")
1049            >>> stock.get_ttm_income_stmt()
1050
1051            >>> bank = bp.Ticker("AKBNK")
1052            >>> bank.get_ttm_income_stmt(financial_group="UFRS")
1053        """
1054        quarterly = self.get_income_stmt(quarterly=True, financial_group=financial_group)
1055        return self._calculate_ttm(quarterly)
1056
1057    def get_ttm_cashflow(self, financial_group: str | None = None) -> pd.DataFrame:
1058        """
1059        Get trailing twelve months (TTM) cash flow statement.
1060
1061        Calculates TTM by summing the last 4 quarters of cash flow data.
1062
1063        Args:
1064            financial_group: Financial group code. Use "UFRS" for banks,
1065                           "XI_29" for industrial companies. If None, defaults to XI_29.
1066
1067        Returns:
1068            DataFrame with TTM column containing summed values for each line item.
1069
1070        Examples:
1071            >>> stock = bp.Ticker("THYAO")
1072            >>> stock.get_ttm_cashflow()
1073
1074            >>> bank = bp.Ticker("AKBNK")
1075            >>> bank.get_ttm_cashflow(financial_group="UFRS")
1076        """
1077        quarterly = self.get_cashflow(quarterly=True, financial_group=financial_group)
1078        return self._calculate_ttm(quarterly)
1079
1080    # Legacy property aliases
1081    @cached_property
1082    def ttm_income_stmt(self) -> pd.DataFrame:
1083        """TTM income statement (use get_ttm_income_stmt() for banks)."""
1084        return self.get_ttm_income_stmt()
1085
1086    @cached_property
1087    def ttm_cashflow(self) -> pd.DataFrame:
1088        """TTM cash flow (use get_ttm_cashflow() for banks)."""
1089        return self.get_ttm_cashflow()
1090
1091    @cached_property
1092    def major_holders(self) -> pd.DataFrame:
1093        """
1094        Get major shareholders (ortaklık yapısı).
1095
1096        Returns:
1097            DataFrame with shareholder names and percentages:
1098            - Index: Holder name
1099            - Percentage: Ownership percentage (%)
1100
1101        Examples:
1102            >>> stock = Ticker("THYAO")
1103            >>> stock.major_holders
1104                                     Percentage
1105            Holder
1106            Diğer                        50.88
1107            Türkiye Varlık Fonu          49.12
1108        """
1109        return self._get_isyatirim().get_major_holders(self._symbol)
1110
1111    @cached_property
1112    def recommendations(self) -> dict:
1113        """
1114        Get analyst recommendations and target price.
1115
1116        Returns:
1117            Dictionary with:
1118            - recommendation: Buy/Hold/Sell (AL/TUT/SAT)
1119            - target_price: Analyst target price (TL)
1120            - upside_potential: Expected upside (%)
1121
1122        Examples:
1123            >>> stock = Ticker("THYAO")
1124            >>> stock.recommendations
1125            {'recommendation': 'AL', 'target_price': 579.99, 'upside_potential': 116.01}
1126        """
1127        return self._get_isyatirim().get_recommendations(self._symbol)
1128
1129    @cached_property
1130    def recommendations_summary(self) -> dict[str, int]:
1131        """
1132        Get analyst recommendation summary with buy/hold/sell counts.
1133
1134        Aggregates individual analyst recommendations from hedeffiyat.com.tr
1135        into yfinance-compatible categories.
1136
1137        Returns:
1138            Dictionary with counts:
1139            - strongBuy: Strong buy recommendations
1140            - buy: Buy recommendations (includes "Endeks Üstü Getiri")
1141            - hold: Hold recommendations (includes "Nötr", "Endekse Paralel")
1142            - sell: Sell recommendations (includes "Endeks Altı Getiri")
1143            - strongSell: Strong sell recommendations
1144
1145        Examples:
1146            >>> stock = Ticker("THYAO")
1147            >>> stock.recommendations_summary
1148            {'strongBuy': 0, 'buy': 31, 'hold': 0, 'sell': 0, 'strongSell': 0}
1149        """
1150        return self._get_hedeffiyat().get_recommendations_summary(self._symbol)
1151
1152    @cached_property
1153    def news(self) -> pd.DataFrame:
1154        """
1155        Get recent KAP (Kamuyu Aydınlatma Platformu) disclosures for the stock.
1156
1157        Fetches directly from KAP - the official disclosure platform for
1158        publicly traded companies in Turkey.
1159
1160        Returns:
1161            DataFrame with columns:
1162            - Date: Disclosure date and time
1163            - Title: Disclosure headline
1164            - URL: Link to full disclosure on KAP
1165
1166        Examples:
1167            >>> stock = Ticker("THYAO")
1168            >>> stock.news
1169                              Date                                         Title                                         URL
1170            0  29.12.2025 19:21:18  Haber ve Söylentilere İlişkin Açıklama  https://www.kap.org.tr/tr/Bildirim/1530826
1171            1  29.12.2025 16:11:36  Payların Geri Alınmasına İlişkin Bildirim  https://www.kap.org.tr/tr/Bildirim/1530656
1172        """
1173        return self._get_kap().get_disclosures(self._symbol)
1174
1175    def get_news_content(self, disclosure_id: int | str) -> str | None:
1176        """
1177        Get full HTML content of a KAP disclosure by ID.
1178
1179        Args:
1180            disclosure_id: KAP disclosure ID from news DataFrame URL.
1181
1182        Returns:
1183            Raw HTML content or None if failed.
1184
1185        Examples:
1186            >>> stock = Ticker("THYAO")
1187            >>> html = stock.get_news_content(1530826)
1188        """
1189        return self._get_kap().get_disclosure_content(disclosure_id)
1190
1191    @cached_property
1192    def calendar(self) -> pd.DataFrame:
1193        """
1194        Get expected disclosure calendar for the stock from KAP.
1195
1196        Returns upcoming expected disclosures like financial reports,
1197        annual reports, sustainability reports, and corporate governance reports.
1198
1199        Returns:
1200            DataFrame with columns:
1201            - StartDate: Expected disclosure window start
1202            - EndDate: Expected disclosure window end
1203            - Subject: Type of disclosure (e.g., "Finansal Rapor")
1204            - Period: Report period (e.g., "Yıllık", "3 Aylık")
1205            - Year: Fiscal year
1206
1207        Examples:
1208            >>> stock = Ticker("THYAO")
1209            >>> stock.calendar
1210                  StartDate       EndDate               Subject   Period  Year
1211            0  01.01.2026  11.03.2026       Finansal Rapor   Yıllık  2025
1212            1  01.01.2026  11.03.2026    Faaliyet Raporu  Yıllık  2025
1213            2  01.04.2026  11.05.2026       Finansal Rapor  3 Aylık  2026
1214        """
1215        return self._get_kap().get_calendar(self._symbol)
1216
1217    @cached_property
1218    def isin(self) -> str | None:
1219        """
1220        Get ISIN (International Securities Identification Number) code.
1221
1222        ISIN is a 12-character alphanumeric code that uniquely identifies
1223        a security, standardized by ISO 6166.
1224
1225        Returns:
1226            ISIN code string (e.g., "TRATHYAO91M5") or None if not found.
1227
1228        Examples:
1229            >>> stock = Ticker("THYAO")
1230            >>> stock.isin
1231            'TRATHYAO91M5'
1232        """
1233        return self._get_isin_provider().get_isin(self._symbol)
1234
1235    @cached_property
1236    def analyst_price_targets(self) -> dict[str, float | int | None]:
1237        """
1238        Get analyst price target data from hedeffiyat.com.tr.
1239
1240        Returns aggregated price target information from multiple analysts.
1241
1242        Returns:
1243            Dictionary with:
1244            - current: Current stock price
1245            - low: Lowest analyst target price
1246            - high: Highest analyst target price
1247            - mean: Average target price
1248            - median: Median target price
1249            - numberOfAnalysts: Number of analysts covering the stock
1250
1251        Examples:
1252            >>> stock = Ticker("THYAO")
1253            >>> stock.analyst_price_targets
1254            {'current': 268.5, 'low': 388.0, 'high': 580.0, 'mean': 474.49,
1255             'median': 465.0, 'numberOfAnalysts': 19}
1256        """
1257        return self._get_hedeffiyat().get_price_targets(self._symbol)
1258
1259    @property
1260    def etf_holders(self) -> pd.DataFrame:
1261        """
1262        Get international ETFs that hold this stock.
1263
1264        Returns data from TradingView showing which ETFs hold this stock,
1265        including position value, weight, and ETF characteristics.
1266
1267        Returns:
1268            DataFrame with ETF holder information:
1269            - symbol: ETF ticker symbol
1270            - exchange: Exchange (AMEX, NASDAQ, LSE, etc.)
1271            - name: ETF full name
1272            - market_cap_usd: Position value in USD
1273            - holding_weight_pct: Weight percentage (0.09 = 0.09%)
1274            - issuer: ETF issuer (BlackRock, Vanguard, etc.)
1275            - management: Management style (Passive/Active)
1276            - focus: Investment focus (Total Market, Emerging Markets, etc.)
1277            - expense_ratio: Expense ratio (0.09 = 0.09%)
1278            - aum_usd: Total assets under management (USD)
1279            - price: Current ETF price
1280            - change_pct: Change percentage
1281
1282        Examples:
1283            >>> stock = Ticker("ASELS")
1284            >>> holders = stock.etf_holders
1285            >>> holders[['symbol', 'name', 'holding_weight_pct']].head()
1286               symbol                                      name  holding_weight_pct
1287            0    IEMG  iShares Core MSCI Emerging Markets ETF            0.090686
1288            1     VWO     Vanguard FTSE Emerging Markets ETF            0.060000
1289
1290            >>> print(f"Total ETFs: {len(holders)}")
1291            Total ETFs: 118
1292        """
1293        return self._get_etf_provider().get_etf_holders(self._symbol)
1294
1295    @cached_property
1296    def earnings_dates(self) -> pd.DataFrame:
1297        """
1298        Get upcoming earnings announcement dates.
1299
1300        Derived from KAP calendar, showing expected financial report dates.
1301        Compatible with yfinance earnings_dates format.
1302
1303        Returns:
1304            DataFrame with index as Earnings Date and columns:
1305            - EPS Estimate: Always None (not available for BIST)
1306            - Reported EPS: Always None (not available for BIST)
1307            - Surprise (%): Always None (not available for BIST)
1308
1309        Examples:
1310            >>> stock = Ticker("THYAO")
1311            >>> stock.earnings_dates
1312                            EPS Estimate  Reported EPS  Surprise(%)
1313            Earnings Date
1314            2026-03-11           None          None         None
1315            2026-05-11           None          None         None
1316        """
1317        cal = self.calendar
1318        if cal.empty:
1319            return pd.DataFrame(
1320                columns=["EPS Estimate", "Reported EPS", "Surprise(%)"]
1321            )
1322
1323        # Filter for financial reports only
1324        financial_reports = cal[
1325            cal["Subject"].str.contains("Finansal Rapor", case=False, na=False)
1326        ]
1327
1328        if financial_reports.empty:
1329            return pd.DataFrame(
1330                columns=["EPS Estimate", "Reported EPS", "Surprise(%)"]
1331            )
1332
1333        # Use EndDate as the earnings date (latest expected date)
1334        earnings_dates = []
1335        for _, row in financial_reports.iterrows():
1336            end_date = row.get("EndDate", "")
1337            if end_date:
1338                try:
1339                    # Parse Turkish date format (DD.MM.YYYY)
1340                    parsed = datetime.strptime(end_date, "%d.%m.%Y")
1341                    earnings_dates.append(parsed)
1342                except ValueError:
1343                    continue
1344
1345        if not earnings_dates:
1346            return pd.DataFrame(
1347                columns=["EPS Estimate", "Reported EPS", "Surprise(%)"]
1348            )
1349
1350        result = pd.DataFrame(
1351            {
1352                "EPS Estimate": [None] * len(earnings_dates),
1353                "Reported EPS": [None] * len(earnings_dates),
1354                "Surprise(%)": [None] * len(earnings_dates),
1355            },
1356            index=pd.DatetimeIndex(earnings_dates, name="Earnings Date"),
1357        )
1358        result = result.sort_index()
1359        return result
1360
1361    def _parse_date(self, date: str | datetime) -> datetime:
1362        """Parse a date string to datetime."""
1363        if isinstance(date, datetime):
1364            return date
1365        # Try common formats
1366        for fmt in ["%Y-%m-%d", "%Y/%m/%d", "%d-%m-%Y", "%d/%m/%Y"]:
1367            try:
1368                return datetime.strptime(date, fmt)
1369            except ValueError:
1370                continue
1371        raise ValueError(f"Could not parse date: {date}")
1372
1373    def _get_ta_symbol_info(self) -> tuple[str, str]:
1374        """Get TradingView symbol and screener for TA signals.
1375
1376        Returns:
1377            Tuple of (tv_symbol, screener) for TradingView Scanner API.
1378        """
1379        return (f"BIST:{self._symbol}", "turkey")
1380
1381    def __repr__(self) -> str:
1382        return f"Ticker('{self._symbol}')"