Borsa Stratejileri 2

Bu Python betiği, X_01_BorsaPin_StokData.py  Python betiğiyle oluşturulan StokData/Kapanis klasöründeki hisse kapanış verilerinden lineer regresyon trend analizi ve Pearson korelasyon ölçümleri yaparak detaylı teknik analiz raporu üretir. Analizler, Excel formatında renklendirilmiş ve filtrelenebilir şekilde kayıt altına alınır.

Terminalden şu iki komutu çalıştırın .
python.exe -m pip install --upgrade pip
pip install pandas numpy scipy colorama openpyxl

Kodun Temel Özellikleri

Lineer Regresyon Analizi: Kapanış fiyatları üzerinden trend çizgisi (slope), kanal bandı, standart sapma gibi metrikleri hesaplar.
Pearson Korelasyon: Trendin gücünü ölçmek için farklı periyotlarda Pearson korelasyon katsayısı hesaplanır.

Fırsat Tespiti:

Kanal Altı Fırsatları: Alt banda yakın fiyat hareketleri ve güçlü korelasyon içeren hisseler.

Breakout Adayları: Üst banda yakın olup yükseliş sinyali veren hisseler.

EMA Dizilim Entegrasyonu: Farklı script tarafından oluşturulan EMA analizleriyle birleştirilebilir.

Otomatik Excel Raporu: Tüm veriler biçimlendirilmiş bir Excel dosyasına kaydedilir (filtrelenebilir, renklendirilmiş).

Başarısız Dosya Takibi: Hatalı veriler ayrı bir .txt dosyasına kaydedilir. Analiz Süreci Otomatik Gerçekleşir:

Tüm dosyalar sırasıyla işlenir. Lineer regresyon analizleri yapılır. Fırsatlar belirlenir. Sonuçlar Excel ve TXT dosyalarına kaydedilir.

Üretilen Dosyalar

StokData/lineer_regresyon_analiz.xlsx → Ana analiz dosyası
StokData/LinearRegression/lineer_regresyon_analiz_YYYY-MM-DD.xlsx → Arşiv dosyası

basarisiz_regresyon_dosyalari.txt → Başarısız analizlerin listesi

Excel Sayfaları
TumSonuclar: Tüm hisse ve periyot sonuçları
IdealPearson: En güçlü Pearson korelasyonuna sahip hisseler
KanalFirsatlari_Top50: Kanal altına yakın fırsatlar
BreakoutAdaylari_Top50: Yükselişe aday hisseler
Periyot_XXX: Her analiz periyodu için ayrı sayfalar
Istatistikler: Genel başarı ve analiz özetleri

Avantajları

Otomatik, hızlı ve güvenilir teknik analiz.  Yatırım kararlarını destekleyecek fırsat ve sinyal tespiti. Excel üzerinden kolay görsel analiz ve filtreleme imkânı

Bu betik, teknik analizde trend doğruluğunu ve fırsatları istatistiksel olarak belirlemek isteyen yatırımcılar için güçlü bir araçtır. Özellikle BIST verileriyle çalışan sistemlerde regresyon ve Pearson tabanlı analiz ile öne çıkan hisseleri kolayca tespit etmeye yardımcı olur.

LinReg tarama çalışmamızı X_05_BorsaPin_LinReg_Tarama.py adıyla kayıt edebilirsiniz.
Python Betiği

import pandas as pd
import numpy as np
import os
import glob
from scipy.stats import linregress, pearsonr
from datetime import datetime, timedelta
from colorama import Fore, init
from openpyxl.styles import Font, PatternFill, Alignment
from openpyxl.utils import get_column_letter
from typing import List, Dict, Optional

"""
      Borsapin StokData/Kapanis klasöründeki hisse verilerinden Lineer Regresyon ve Pearson analizi yapar
      www.kursatsenturk.com

      """

init(autoreset=True)


class LinearRegressionAnalyzer:
    def __init__(self):
        self.pearson_periods = [55, 89, 144, 233, 370, 610, 987]
        self.analysis_periods = [55, 89, 144, 233, 370, 610, 987]  # Özel analiz periyotları
        self.successful_files = []
        self.failed_files = []

        # Sonuç listeleri
        self.all_results = []
        self.period_results = {period: [] for period in self.pearson_periods}
        self.ideal_pearson = []
        self.channel_opportunities = []
        self.breakout_candidates = []
        self.statistics = {}

    @staticmethod
    def calculate_regression(data_df: pd.DataFrame, period: int) -> Optional[Dict]:
        """Lineer regresyon ve kanal hesaplama"""
        try:
            # Son 'period' a kadar veriyi al
            data_df = data_df.tail(period).copy()
            if len(data_df) < period:
                return None

            # X ekseni (zaman) ve Y ekseni (fiyat) değerleri
            x = np.arange(len(data_df))
            y = data_df["Kapanış"].values

            # Lineer regresyon hesaplama
            slope, intercept, r_value, p_value, std_err = linregress(x, y)

            # Trend çizgisi hesaplama
            trend_line = intercept + slope * x

            # Residual (artık) değerler ve standart sapma
            residuals = y - trend_line
            std_dev = np.std(residuals)

            # Kanal bantları (2 standart sapma)
            upper_channel = trend_line + 2 * std_dev
            lower_channel = trend_line - 2 * std_dev

            # Pearson korelasyon katsayısı
            corr, _ = pearsonr(x, y)

            # Son değerler
            upper_channel_value = round(float(upper_channel[-1]), 2)
            lower_channel_value = round(float(lower_channel[-1]), 2)
            trend_value = round(float(trend_line[-1]), 2)
            last_price = float(y[-1])

            # Yüzde farkları
            upper_diff_pct = round((last_price - upper_channel_value) / last_price * 100, 2)
            lower_diff_pct = round((last_price - lower_channel_value) / last_price * 100, 2)
            trend_diff_pct = round((last_price - trend_value) / last_price * 100, 2)

            # Trend yönü ve güç
            trend_direction = "Yükseliş" if slope > 0 else "Düşüş"
            trend_strength = "Güçlü" if abs(slope) > 0.05 else "Orta" if abs(slope) > 0.01 else "Zayıf"

            # Kanal pozisyonu
            channel_position = "Üst Bant" if upper_diff_pct >= -2 else "Alt Bant" if lower_diff_pct <= 2 else "Orta"

            return {
                "Periyot": period,
                "Kanal_Ust": upper_channel_value,
                "Kanal_Alt": lower_channel_value,
                "Trend_Cizgisi": trend_value,
                "Ust_Fark_Pct": upper_diff_pct,
                "Alt_Fark_Pct": lower_diff_pct,
                "Trend_Fark_Pct": trend_diff_pct,
                "Trend_Yonu": trend_direction,
                "Trend_Gucu": trend_strength,
                "Kanal_Pozisyonu": channel_position,
                "Pearson": round(corr, 4),
                "R_Kare": round(r_value ** 2, 4),
                "Slope": round(slope, 6),
                "P_Value": round(p_value, 6),
                "Std_Error": round(std_err, 6)
            }

        except Exception as e:
            print(f"{Fore.RED}❌ Regresyon hesaplama hatası (Period {period}): {e}")
            return None

    def process_single_file(self, file_path: str) -> bool:
        """Tek dosya için lineer regresyon analizi"""
        ticker_name = None
        try:
            # Dosya adından hisse adını alma
            file_name = os.path.basename(file_path)
            ticker_name = os.path.splitext(file_name)[0]

            print(f"{Fore.YELLOW} Lineer regresyon analizi: {ticker_name}...")

            # Excel dosyasını okuma
            df = pd.read_excel(file_path)

            # Gerekli sütunların varlığını kontrol etme
            if 'Tarih' not in df.columns or 'Kapanış' not in df.columns:
                raise ValueError("Tarih veya Kapanış sütunu bulunamadı")

            # Veri temizleme ve sıralama
            df = df[["Tarih", "Kapanış"]].dropna()
            df["Tarih"] = pd.to_datetime(df["Tarih"])
            df = df.sort_values("Tarih").reset_index(drop=True)
            df["Kapanış"] = pd.to_numeric(df["Kapanış"], errors='coerce')
            df = df.dropna()

            if df.empty:
                raise ValueError("Veri boş veya geçersiz")

            last_close = round(float(df["Kapanış"].iloc[-1]), 2)
            last_date = df["Tarih"].iloc[-1]

            print(f"{Fore.CYAN}   ⚡ Periyotlar hesaplanıyor: ", end="")

            # Her periyot için analiz
            ticker_pearson_data = {"Hisse_Adi": ticker_name, "Kapanış": last_close, "Tarih": last_date}

            for i, period in enumerate(self.pearson_periods):
                print(f"{period}", end="")

                result = self.calculate_regression(df.copy(), period)
                if result:
                    # Ana sonuç listesine ekle
                    main_result = {
                        "Hisse_Adi": ticker_name,
                        "Kapanış": last_close,
                        "Tarih": last_date,
                        **result
                    }
                    self.all_results.append(main_result)

                    # Periyot bazlı sonuçlara ekle
                    self.period_results[period].append(main_result)

                    # İdeal Pearson için veri toplama
                    ticker_pearson_data[f"Pearson_{period}"] = result["Pearson"]
                    ticker_pearson_data[f"Kanal_Pozisyon_{period}"] = result["Kanal_Pozisyonu"]
                    ticker_pearson_data[f"Alt_Fark_{period}"] = result["Alt_Fark_Pct"]
                    ticker_pearson_data[f"Ust_Fark_{period}"] = result["Ust_Fark_Pct"]

                if i < len(self.pearson_periods) - 1:
                    print(", ", end="")
            print()

            # İdeal Pearson listesine ekle
            self.ideal_pearson.append(ticker_pearson_data)

            # Özel analizler için kontrol
            self.analyze_opportunities(ticker_name, last_close, last_date, df)

            print(f"{Fore.GREEN}✅ {ticker_name} analizi tamamlandı.")
            self.successful_files.append(ticker_name)
            return True

        except Exception as e:
            print(f"{Fore.RED}❌ {ticker_name if ticker_name else file_path} için hata: {e}")
            self.failed_files.append(os.path.basename(file_path))
            return False

    def analyze_opportunities(self, ticker_name: str, last_close: float, last_date, df: pd.DataFrame):
        """Fırsat analizi - kanal alt bandı ve breakout adayları"""
        try:
            for period in self.analysis_periods:
                result = self.calculate_regression(df.copy(), period)
                if result:
                    # Alt banda yakın fırsatlar (Alt fark <= 4% ve Pearson >= 0.7)
                    if (-2 <= result["Alt_Fark_Pct"] <= 4 and
                            abs(result["Pearson"]) >= 0.7):
                        self.channel_opportunities.append({
                            "Hisse_Adi": ticker_name,
                            "Kapanış": last_close,
                            "Tarih": last_date,
                            "Periyot": period,
                            "Alt_Fark_Pct": result["Alt_Fark_Pct"],
                            "Pearson": result["Pearson"],
                            "Trend_Yonu": result["Trend_Yonu"],
                            "Kanal_Alt": result["Kanal_Alt"],
                            "Kanal_Ust": result["Kanal_Ust"],
                            "Potansiyel_Kazanc": round((result["Kanal_Ust"] - last_close) / last_close * 100, 2)
                        })

                    # Breakout adayları (Üst fark >= -4% ve Pearson >= 0.8)
                    if (-4 <= result["Ust_Fark_Pct"] <= 2 and
                            abs(result["Pearson"]) >= 0.8):
                        self.breakout_candidates.append({
                            "Hisse_Adi": ticker_name,
                            "Kapanış": last_close,
                            "Tarih": last_date,
                            "Periyot": period,
                            "Ust_Fark_Pct": result["Ust_Fark_Pct"],
                            "Pearson": result["Pearson"],
                            "Trend_Yonu": result["Trend_Yonu"],
                            "Kanal_Ust": result["Kanal_Ust"],
                            "Hedef_Fiyat": round(result["Kanal_Ust"] * 1.05, 2)  # %5 üst hedef
                        })

        except Exception as e:
            print(f"{Fore.RED}❌ Fırsat analizi hatası ({ticker_name}): {e}")

    def calculate_statistics(self):
        """İstatistik hesaplama"""
        try:
            print(f"{Fore.CYAN} İstatistikler hesaplanıyor...")

            # Genel istatistikler
            stats = {
                "Toplam_Analiz_Edilen": len(self.successful_files),
                "Basarisiz_Dosya": len(self.failed_files)
            }

            # Periyot bazlı istatistikler
            for period in self.pearson_periods:
                period_data = self.period_results[period]
                if period_data:
                    pearson_values = [item["Pearson"] for item in period_data if item.get("Pearson")]
                    stats[f"Ortalama_Pearson_{period}"] = round(np.mean(pearson_values), 4) if pearson_values else 0
                    stats[f"Yuksek_Pearson_Sayisi_{period}"] = len([p for p in pearson_values if abs(p) >= 0.8])

            # Fırsat istatistikleri
            stats["Kanal_Alt_Firsatlari"] = len(self.channel_opportunities)
            stats["Breakout_Adaylari"] = len(self.breakout_candidates)

            # Trend analizi
            trend_up = len([item for item in self.all_results if item.get("Trend_Yonu") == "Yükseliş"])
            trend_down = len([item for item in self.all_results if item.get("Trend_Yonu") == "Düşüş"])
            stats["Yukselis_Trendi"] = trend_up
            stats["Dusus_Trendi"] = trend_down

            self.statistics = stats
            return stats

        except Exception as e:
            print(f"{Fore.RED}❌ İstatistik hesaplama hatası: {e}")
            return {}

    @staticmethod
    def find_input_files(input_folder="StokData/Kapanis/"):
        """Giriş dosyalarını bulma"""
        try:
            pattern = os.path.join(input_folder, "*.xlsx")
            files = glob.glob(pattern)

            if not files:
                print(f"{Fore.RED}❌ {input_folder} klasöründe Excel dosyası bulunamadı!")
                return []

            print(f"{Fore.BLUE} {len(files)} adet Excel dosyası bulundu.")
            return files

        except Exception as e:
            print(f"{Fore.RED}❌ Dosya arama hatası: {e}")
            return []

    def merge_ema_data(self):
        """EMA dizilim verilerini birleştirme"""
        try:
            ema_file = "StokData/idealema_analiz.xlsx"
            if os.path.exists(ema_file):
                print(f"{Fore.CYAN} EMA verileri birleştiriliyor...")
                ema_df = pd.read_excel(ema_file, sheet_name="IdealEMAUp")
                ema_mapping = dict(zip(ema_df["Hisse_Adi"], ema_df["EMA_Dizilim"]))

                # Tüm sonuçlara EMA bilgisi ekle
                for result in self.all_results:
                    result["EMA_Dizilim"] = ema_mapping.get(result["Hisse_Adi"], "Bilinmiyor")

                for result in self.ideal_pearson:
                    result["EMA_Dizilim"] = ema_mapping.get(result["Hisse_Adi"], "Bilinmiyor")

                print(f"{Fore.GREEN}✅ EMA verileri başarıyla birleştirildi.")
            else:
                print(f"{Fore.YELLOW}⚠️  EMA dosyası bulunamadı: {ema_file}")

        except Exception as e:
            print(f"{Fore.RED}❌ EMA veri birleştirme hatası: {e}")

    @staticmethod
    def write_sheet_with_formatting(excel_writer, df, sheet_name, freeze_panes=None):
        """Excel sayfası yazma ve biçimlendirme"""
        try:
            if isinstance(df, list):
                df = pd.DataFrame(df)

            if df.empty:
                df = pd.DataFrame([{"Mesaj": "Veri bulunamadı"}])

            df.to_excel(excel_writer, sheet_name=sheet_name, index=False)
            ws = excel_writer.sheets[sheet_name]

            # Başlık biçimlendirme
            header_fill = PatternFill(start_color='4472C4', end_color='4472C4', fill_type='solid')
            for col_num, column in enumerate(df.columns, 1):
                cell = ws.cell(row=1, column=col_num)
                cell.font = Font(bold=True, color='FFFFFF')
                cell.fill = header_fill
                cell.alignment = Alignment(horizontal='center')

                # Sütun genişlikleri
                if any(keyword in str(column) for keyword in ['Tarih', 'Date']):
                    ws.column_dimensions[get_column_letter(col_num)].width = 15
                elif any(keyword in str(column) for keyword in ['Hisse', 'CODE']):
                    ws.column_dimensions[get_column_letter(col_num)].width = 12
                elif any(keyword in str(column) for keyword in ['Pearson', 'Fark', 'Pct']):
                    ws.column_dimensions[get_column_letter(col_num)].width = 18
                else:
                    ws.column_dimensions[get_column_letter(col_num)].width = 20

            # Veri satırlarını biçimlendirme
            for row_num in range(2, len(df) + 2):
                for col_num in range(1, len(df.columns) + 1):
                    cell = ws.cell(row=row_num, column=col_num)
                    cell.alignment = Alignment(horizontal='center')
                    column_name = df.columns[col_num - 1]

                    # Pearson değerleri için renklendirme
                    if 'Pearson' in str(column_name) and isinstance(cell.value, (int, float)):
                        if abs(cell.value) >= 0.9:
                            cell.fill = PatternFill(start_color='00FF00', end_color='00FF00', fill_type='solid')
                        elif abs(cell.value) >= 0.8:
                            cell.fill = PatternFill(start_color='90EE90', end_color='90EE90', fill_type='solid')
                        elif abs(cell.value) >= 0.7:
                            cell.fill = PatternFill(start_color='FFFF99', end_color='FFFF99', fill_type='solid')

                    # Fark yüzdeleri için renklendirme
                    elif 'Alt_Fark' in str(column_name) and isinstance(cell.value, (int, float)):
                        if -2 <= cell.value <= 4:
                            cell.fill = PatternFill(start_color='FFFFCC', end_color='FFFFCC', fill_type='solid')

                    elif 'Ust_Fark' in str(column_name) and isinstance(cell.value, (int, float)):
                        if -4 <= cell.value <= 2:
                            cell.fill = PatternFill(start_color='FFCCCC', end_color='FFCCCC', fill_type='solid')

            # Freeze panes
            if freeze_panes:
                ws.freeze_panes = freeze_panes

            # AutoFilter ekleme (başlık satırına)
            if len(df) > 0:
                ws.auto_filter.ref = f"A1:{get_column_letter(len(df.columns))}{len(df) + 1}"

        except Exception as e:
            print(f"{Fore.RED}❌ Excel biçimlendirme hatası ({sheet_name}): {e}")

    def save_results(self):
        """Sonuçları Excel'e kaydetme"""
        try:
            # Klasörler oluşturma
            output_folder = "StokData/LinearRegression/"
            os.makedirs(output_folder, exist_ok=True)

            # Dosya isimleri
            today = datetime.today().strftime('%Y-%m-%d')
            main_file = os.path.join("StokData", "lineer_regresyon_analiz.xlsx")
            archive_file = os.path.join(output_folder, f"lineer_regresyon_analiz_{today}.xlsx")

            # Veri hazırlama
            print(f"{Fore.GREEN} Excel dosyası hazırlanıyor...")

            # Sıralama işlemleri
            # İdeal Pearson - maksimum mutlak Pearson değerine göre sırala
            ideal_pearson_df = pd.DataFrame(self.ideal_pearson)
            if not ideal_pearson_df.empty:
                pearson_cols = [col for col in ideal_pearson_df.columns if 'Pearson_' in col]
                if pearson_cols:
                    ideal_pearson_df['Max_Abs_Pearson'] = ideal_pearson_df[pearson_cols].abs().max(axis=1)
                    ideal_pearson_df = ideal_pearson_df.sort_values('Max_Abs_Pearson', ascending=False)

            # Kanal fırsatları - Pearson değerine göre sırala (İlk 50)
            channel_opp_df = pd.DataFrame(self.channel_opportunities)
            if not channel_opp_df.empty:
                channel_opp_df = channel_opp_df.sort_values(['Pearson', 'Alt_Fark_Pct'], ascending=[False, True]).head(
                    50)

            # Breakout adayları - Pearson değerine göre sırala (İlk 50)
            breakout_df = pd.DataFrame(self.breakout_candidates)
            if not breakout_df.empty:
                breakout_df = breakout_df.sort_values(['Pearson', 'Ust_Fark_Pct'], ascending=[False, False]).head(50)

            # İstatistikler
            stats_df = pd.DataFrame([
                {"Metrik": key, "Deger": value} for key, value in self.statistics.items()
            ])

            # Ana dosyayı kaydet
            print(f"{Fore.GREEN} Ana dosya kaydediliyor: {main_file}")
            with pd.ExcelWriter(main_file, engine='openpyxl') as writer:
                # Ana sayfalar
                self.write_sheet_with_formatting(writer, pd.DataFrame(self.all_results), "TumSonuclar", "A2")
                self.write_sheet_with_formatting(writer, ideal_pearson_df, "IdealPearson", "A2")
                self.write_sheet_with_formatting(writer, channel_opp_df, "KanalFirsatlari_Top50", "A2")
                self.write_sheet_with_formatting(writer, breakout_df, "BreakoutAdaylari_Top50", "A2")
                self.write_sheet_with_formatting(writer, stats_df, "Istatistikler", "A2")

                # Periyot bazlı sayfalar
                for period in self.pearson_periods:
                    period_df = pd.DataFrame(self.period_results[period])
                    if not period_df.empty:
                        period_df = period_df.sort_values('Pearson', ascending=False)
                        self.write_sheet_with_formatting(writer, period_df, f"Periyot_{period}", "A2")

            # Arşiv dosyasını kaydet
            print(f"{Fore.BLUE} Arşiv dosyası kaydediliyor: {archive_file}")
            with pd.ExcelWriter(archive_file, engine='openpyxl') as writer:
                self.write_sheet_with_formatting(writer, pd.DataFrame(self.all_results), "TumSonuclar", "A2")
                self.write_sheet_with_formatting(writer, ideal_pearson_df, "IdealPearson", "A2")
                self.write_sheet_with_formatting(writer, channel_opp_df, "KanalFirsatlari_Top50", "A2")
                self.write_sheet_with_formatting(writer, breakout_df, "BreakoutAdaylari_Top50", "A2")
                self.write_sheet_with_formatting(writer, stats_df, "Istatistikler", "A2")

                for period in self.pearson_periods:
                    period_df = pd.DataFrame(self.period_results[period])
                    if not period_df.empty:
                        period_df = period_df.sort_values('Pearson', ascending=False)
                        self.write_sheet_with_formatting(writer, period_df, f"Periyot_{period}", "A2")

            return True

        except Exception as e:
            print(f"{Fore.RED}❌ Sonuç kaydetme hatası: {e}")
            return False

    def print_summary(self):
        """Özet rapor"""
        total = len(self.successful_files) + len(self.failed_files)
        success_rate = (len(self.successful_files) / total * 100) if total > 0 else 0

        print(f"\n{Fore.CYAN} ===== LİNEER REGRESYON ANALİZ RAPORU =====")
        print(f"{Fore.BLUE} Analiz Periyotları: {', '.join(map(str, self.pearson_periods))}")
        print(f"{Fore.GREEN}✅ Başarılı: {len(self.successful_files)}")
        print(f"{Fore.RED}❌ Başarısız: {len(self.failed_files)}")
        print(f"{Fore.BLUE} Başarı oranı: {success_rate:.1f}%")

        print(f"\n{Fore.MAGENTA} SONUÇLAR:")
        print(f"{Fore.GREEN}   Toplam Analiz: {len(self.all_results)}")
        print(f"{Fore.YELLOW}   Kanal Alt Fırsatları: {len(self.channel_opportunities)}")
        print(f"{Fore.RED}   Breakout Adayları: {len(self.breakout_candidates)}")
        print(f"{Fore.BLUE}   İdeal Pearson Sayısı: {len(self.ideal_pearson)}")

        # En yüksek Pearson değerleri
        if self.all_results:
            high_pearson = [r for r in self.all_results if abs(r.get('Pearson', 0)) >= 0.9]
            print(f"{Fore.GREEN}  ⭐ Yüksek Pearson (>=0.9): {len(high_pearson)}")

    def save_failed_list(self, filename="basarisiz_regresyon_dosyalari.txt"):
        """Başarısız dosyaları kaydetme"""
        if self.failed_files:
            try:
                with open(filename, 'w', encoding='utf-8') as f:
                    f.write("# Başarısız Lineer Regresyon analizi dosyaları\n")
                    f.write(f"# Tarih: {datetime.now().strftime('%Y-%m-%d')}\n\n")
                    for file_name in self.failed_files:
                        f.write(f"{file_name}\n")
                print(f"{Fore.YELLOW} Başarısız dosyalar {filename} dosyasına kaydedildi.")
            except Exception as e:
                print(f"{Fore.RED}❌ Başarısız dosya listesi kaydetme hatası: {e}")

    def main(self):
        """Ana fonksiyon"""
        print(f"{Fore.CYAN} Lineer Regresyon ve Pearson Analizi Başlatılıyor...")
        print(f"{Fore.BLUE} Analiz Periyotları: {', '.join(map(str, self.pearson_periods))}")
        print(f"{Fore.BLUE} Özel Analiz Periyotları: {', '.join(map(str, self.analysis_periods))}")

        # Giriş dosyalarını bulma
        input_files = self.find_input_files()

        if not input_files:
            return

        print(f"{Fore.BLUE} Toplam işlenecek dosya: {len(input_files)}\n")

        # Dosyaları işleme
        for i, file_path in enumerate(input_files, 1):
            print(f"\n{Fore.MAGENTA}[{i}/{len(input_files)}] İşleniyor...")
            self.process_single_file(file_path)

        # EMA verilerini birleştirme
        self.merge_ema_data()

        # İstatistikleri hesaplama
        self.calculate_statistics()

        # Sonuçları kaydetme
        success = self.save_results()

        if success:
            self.print_summary()

        # Başarısız dosyaları kaydetme
        self.save_failed_list()

        print(f"\n{Fore.GREEN} Lineer regresyon analizi tamamlandı!")
        print(f"{Fore.BLUE} Ana dosya: StokData/lineer_regresyon_analiz.xlsx")
        print(f"{Fore.BLUE} Arşiv klasörü: StokData/LinearRegression/")


# Kullanım
if __name__ == "__main__":
    analyzer = LinearRegressionAnalyzer()
    analyzer.main()