added in the right github structure

app.py

@@ -6,9 +6,8 @@ import requests
 import google.generativeai as genai
 from collections import defaultdict
 import os
-import time
 import logging
-import csv
+from core.core import analyze_games
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -17,478 +16,7 @@ GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY')
 genai.configure(api_key=GEMINI_API_KEY)
 model = genai.GenerativeModel('gemini-2.0-flash-exp')
 
-def load_opening_database():
-    openings = {}
-    try:
-        with open('Chess Opening Reference - Sheet1.csv', 'r', encoding='utf-8') as f:
-            reader = csv.DictReader(f)
-            for row in reader:
-                eco = row.get('ECO Code', '').strip()
-                name = row.get('Name', '').strip()
-                if eco and name:
-                    openings[eco] = name
-    except Exception as e:
-        logger.error(f"Failed to load openings CSV: {e}")
-    return openings
 
-OPENING_DB = load_opening_database()
-
-def detect_opening(game):
-    eco = game.headers.get("ECO", "")
-    opening = game.headers.get("Opening", "")
-    
-    if eco and eco in OPENING_DB:
-        return OPENING_DB[eco]
-    elif opening:
-        return opening
-    else:
-        return "Unknown Opening"
-
-def get_user_games_from_chess_com(username):
-    try:
-        logger.info(f"Fetching games for: {username}")
-        username = username.strip().lower()
-        
-        user_url = f"https://api.chess.com/pub/player/{username}"
-        response = requests.get(user_url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
-        
-        if response.status_code != 200:
-            return None, f"❌ Foydalanuvchi topilmadi: {username}"
-        
-        archives_url = f"https://api.chess.com/pub/player/{username}/games/archives"
-        response = requests.get(archives_url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
-        
-        if response.status_code != 200:
-            return None, "❌ O'yinlar arxivi topilmadi."
-        
-        archives = response.json()['archives']
-        if not archives:
-            return None, "❌ O'yinlar topilmadi."
-        
-        all_games = []
-        for archive_url in reversed(archives[-3:]):
-            time.sleep(0.3)
-            response = requests.get(archive_url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
-            if response.status_code == 200:
-                games = response.json()['games']
-                all_games.extend(games)
-            if len(all_games) >= 50:
-                break
-        
-        rapid_games = [g for g in all_games if g.get('time_class') in ['rapid', 'blitz']]
-        if not rapid_games:
-            rapid_games = all_games[:50]
-        
-        pgn_list = [g['pgn'] for g in rapid_games[:50] if 'pgn' in g]
-        
-        if not pgn_list:
-            return None, "❌ PGN formatdagi o'yinlar topilmadi."
-        
-        return pgn_list, None
-        
-    except Exception as e:
-        logger.error(f"Error fetching games: {str(e)}")
-        return None, f"❌ Xatolik: {str(e)}"
-
-def parse_pgn_content(pgn_content):
-    games = []
-    if isinstance(pgn_content, list):
-        for pgn_text in pgn_content:
-            try:
-                game = chess.pgn.read_game(io.StringIO(pgn_text))
-                if game:
-                    games.append(game)
-            except:
-                pass
-    else:
-        pgn_io = io.StringIO(pgn_content)
-        while True:
-            try:
-                game = chess.pgn.read_game(pgn_io)
-                if game is None:
-                    break
-                games.append(game)
-            except:
-                break
-    
-    return games
-
-def analyze_game_detailed(game, username):
-    board = game.board()
-    mistakes = []
-    move_number = 0
-    
-    white_player = game.headers.get("White", "").strip().lower()
-    black_player = game.headers.get("Black", "").strip().lower()
-    username_lower = username.strip().lower()
-    
-    user_color = None
-    if username_lower == white_player:
-        user_color = chess.WHITE
-    elif username_lower == black_player:
-        user_color = chess.BLACK
-    
-    result = game.headers.get("Result", "*")
-    opening = detect_opening(game)
-    
-    user_result = None
-    if user_color is not None and result != "*":
-        if result == "1-0":
-            user_result = "win" if user_color == chess.WHITE else "loss"
-        elif result == "0-1":
-            user_result = "win" if user_color == chess.BLACK else "loss"
-        elif result == "1/2-1/2":
-            user_result = "draw"
-    
-    material_values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, chess.ROOK: 5, chess.QUEEN: 9}
-    
-    def count_material(board):
-        total = 0
-        for piece_type in material_values:
-            total += len(board.pieces(piece_type, chess.WHITE)) * material_values[piece_type]
-            total -= len(board.pieces(piece_type, chess.BLACK)) * material_values[piece_type]
-        return total
-    
-    for move in game.mainline_moves():
-        move_number += 1
-        
-        if user_color is not None and board.turn != user_color:
-            board.push(move)
-            continue
-        
-        material_before = count_material(board)
-        board.push(move)
-        material_after = count_material(board)
-        
-        material_loss = abs(material_after - material_before) if board.turn == chess.WHITE else abs(material_before - material_after)
-        
-        moved_piece = board.piece_at(move.to_square)
-        mistake_type = None
-        
-        if material_loss >= 3:
-            mistake_type = 'blunder'
-        elif material_loss >= 1:
-            mistake_type = 'mistake'
-        elif moved_piece and board.is_attacked_by(not board.turn, move.to_square):
-            attackers = len(board.attackers(not board.turn, move.to_square))
-            defenders = len(board.attackers(board.turn, move.to_square))
-            if attackers > defenders:
-                mistake_type = 'hanging_piece'
-        
-        if move_number <= 10:
-            phase = 'opening'
-        elif len(board.piece_map()) <= 10:
-            phase = 'endgame'
-        else:
-            phase = 'middlegame'
-        
-        if mistake_type:
-            mistakes.append({
-                'type': mistake_type,
-                'phase': phase,
-                'move_number': move_number
-            })
-    
-    return {
-        'mistakes': mistakes,
-        'opening': opening,
-        'result': result,
-        'user_color': user_color,
-        'user_result': user_result
-    }
-
-def categorize_mistakes(all_analyses):
-    if not all_analyses:
-        return []
-    
-    blunders = 0
-    regular_mistakes = 0
-    hanging = 0
-    opening = 0
-    middlegame = 0
-    endgame = 0
-    
-    for analysis in all_analyses:
-        for mistake in analysis.get('mistakes', []):
-            mistake_type = mistake.get('type')
-            phase = mistake.get('phase')
-            
-            if mistake_type == 'blunder':
-                blunders += 1
-            elif mistake_type == 'mistake':
-                regular_mistakes += 1
-            elif mistake_type == 'hanging_piece':
-                hanging += 1
-            
-            if phase == 'opening':
-                opening += 1
-            elif phase == 'middlegame':
-                middlegame += 1
-            elif phase == 'endgame':
-                endgame += 1
-    
-    total = blunders + regular_mistakes + hanging + opening + middlegame + endgame
-    
-    if total == 0:
-        return []
-    
-    weaknesses = []
-    
-    if blunders > 0:
-        weaknesses.append({
-            'category': "Qo'pol xatolar",
-            'count': blunders,
-            'percentage': (blunders / total * 100)
-        })
-    
-    if regular_mistakes > 0:
-        weaknesses.append({
-            'category': 'Kichik xatolar',
-            'count': regular_mistakes,
-            'percentage': (regular_mistakes / total * 100)
-        })
-    
-    if hanging > 0:
-        weaknesses.append({
-            'category': 'Himoyasiz qoldirish',
-            'count': hanging,
-            'percentage': (hanging / total * 100)
-        })
-    
-    if opening > 0:
-        weaknesses.append({
-            'category': 'Debyut xatolari',
-            'count': opening,
-            'percentage': (opening / total * 100)
-        })
-    
-    if middlegame > 0:
-        weaknesses.append({
-            'category': "O'rta o'yin xatolari",
-            'count': middlegame,
-            'percentage': (middlegame / total * 100)
-        })
-    
-    if endgame > 0:
-        weaknesses.append({
-            'category': 'Endshpil xatolari',
-            'count': endgame,
-            'percentage': (endgame / total * 100)
-        })
-    
-    weaknesses.sort(key=lambda x: x['count'], reverse=True)
-    
-    return weaknesses
-
-def fetch_lichess_puzzles(themes, count=5):
-    puzzles = []
-    
-    try:
-        url = "https://lichess.org/training"
-        for i in range(count):
-            puzzles.append({
-                'id': f'puzzle_{i+1}',
-                'url': url,
-                'theme': themes[0] if themes else 'Tactics',
-                'rating': 1500
-            })
-    except Exception as e:
-        logger.error(f"Error generating puzzle links: {str(e)}")
-    
-    return puzzles
-
-def get_comprehensive_analysis(weaknesses, opening_stats, color_stats, total_games):
-    weakness_text = "\n".join([f"- {w['category']}: {w['count']} marta ({w['percentage']:.1f}%)" for w in weaknesses])
-    
-    opening_text = "\n".join([f"- {opening}: {stats['total']} o'yin (G'alabalar: {stats['wins']}, Yutqazishlar: {stats['losses']}, Duranglar: {stats['draws']})" 
-                              for opening, stats in list(opening_stats.items())[:5]])
-    
-    color_text = f"Oq rangda: {color_stats['white']['wins']}G-{color_stats['white']['losses']}Y-{color_stats['white']['draws']}D\n"
-    color_text += f"Qora rangda: {color_stats['black']['wins']}G-{color_stats['black']['losses']}Y-{color_stats['black']['draws']}D"
-    
-    prompt = f"""Siz professional шахмат murabbiy va tahlilchisiz. O'yinchining {total_games} ta o'yinini tahlil qildingiz.
-
-STATISTIKA:
-
-Zaif tomonlar:
-{weakness_text}
-
-Eng ko'p o'ynaladigan debyutlar:
-{opening_text}
-
-Rang bo'yicha natijalar:
-{color_text}
-
-Quyidagilarni taqdim eting:
-
-1. **ZAIF TOMONLAR TAHLILI**: Har bir zaif tomonni chuqur tahlil qiling va nima uchun bu muammo kelib chiqayotganini tushuntiring.
-
-2. **SHAXSIY O'QUV REJASI**: Kundalik mashg'ulotlar rejasini tuzing:
-   - Har kuni nechta masala yechish kerak va qanday turdagi masalalar
-   - Qaysi debyutlarni o'rganish kerak
-   - Qaysi o'yin bosqichiga ko'proq e'tibor berish kerak
-   - Kompyuter yoki botlar bilan qanday mashq qilish kerak
-
-3. **TAVSIYA ETILGAN RESURSLAR**:
-   - Kitoblar (muallif va nom bilan)
-   - Onlayn kurslar (Uzchess, Chess.com, Lichess)
-   - YouTube kanallari
-   - Mashq uchun maxsus botlar yoki dasturlar
-
-4. **DEBYUT TAVSIYALARI**: Statistikaga asoslanib, qaysi debyutlarni davom ettirish va qaysilarini o'zgartirish kerak.
-
-5. **MOTIVATSION XULOSA**: Qisqa va rag'batlantiruvchi xulosa.
-
-MUHIM: Javobni FAQAT O'ZBEK TILIDA yozing! Aniq va amaliy maslahatlar bering."""
-    
-    try:
-        response = model.generate_content(prompt)
-        return response.text
-    except Exception as e:
-        logger.error(f"AI analysis failed: {str(e)}")
-        return f"AI tahlil hozircha mavjud emas: {str(e)}"
-
-def analyze_games(username_chesscom, pgn_file, username_pgn):
-    actual_username = None
-    pgn_content = None
-
-    if username_chesscom:
-        pgn_content, error = get_user_games_from_chess_com(username_chesscom)
-        if error:
-            return error, "", "", "", None, None, None, None, None
-        actual_username = username_chesscom
-    
-    elif pgn_file:
-        pgn_content = pgn_file.decode('utf-8') if isinstance(pgn_file, bytes) else pgn_file
-        
-        if username_pgn and username_pgn.strip():
-            actual_username = username_pgn.strip()
-        else:
-            try:
-                first_game = chess.pgn.read_game(io.StringIO(pgn_content))
-                if first_game:
-                    white = first_game.headers.get("White", "")
-                    black = first_game.headers.get("Black", "")
-                    actual_username = white if white else black if black else "Player"
-                else:
-                    actual_username = "Player"
-            except:
-                actual_username = "Player"
-    
-    else:
-        return "❌ Chess.com foydalanuvchi nomini kiriting yoki PGN faylni yuklang", "", "", "", None, None, None, None, None
-
-    games = parse_pgn_content(pgn_content)
-    
-    if not games:
-        return "❌ O'yinlar topilmadi yoki tahlil qilinmadi", "", "", "", None, None, None, None, None
-    
-    all_analyses = []
-    opening_stats = defaultdict(lambda: {'wins': 0, 'losses': 0, 'draws': 0, 'total': 0})
-    color_stats = {
-        'white': {'wins': 0, 'losses': 0, 'draws': 0},
-        'black': {'wins': 0, 'losses': 0, 'draws': 0}
-    }
-    
-    for game in games:
-        analysis = analyze_game_detailed(game, actual_username)
-        all_analyses.append(analysis)
-        
-        opening = analysis['opening']
-        user_result = analysis.get('user_result')
-        user_color = analysis['user_color']
-        
-        if user_color is not None:
-            opening_stats[opening]['total'] += 1
-            
-            if user_result == 'win':
-                opening_stats[opening]['wins'] += 1
-                color_key = 'white' if user_color == chess.WHITE else 'black'
-                color_stats[color_key]['wins'] += 1
-            elif user_result == 'loss':
-                opening_stats[opening]['losses'] += 1
-                color_key = 'white' if user_color == chess.WHITE else 'black'
-                color_stats[color_key]['losses'] += 1
-            elif user_result == 'draw':
-                opening_stats[opening]['draws'] += 1
-                color_key = 'white' if user_color == chess.WHITE else 'black'
-                color_stats[color_key]['draws'] += 1
-    
-    weaknesses = categorize_mistakes(all_analyses)
-    
-    all_mistakes = []
-    for analysis in all_analyses:
-        all_mistakes.extend(analysis.get('mistakes', []))
-    
-    stats_report = f"## 📊 {len(games)} ta o'yin tahlili\n\n"
-    stats_report += f"**Jami xatolar:** {len(all_mistakes)} ta\n\n"
-    
-    stats_report += "### 🎯 Eng zaif 3 tomoningiz:\n\n"
-    if weaknesses:
-        for i, w in enumerate(weaknesses[:3], 1):
-            stats_report += f"**{i}. {w['category']}** - {w['count']} marta ({w['percentage']:.1f}%)\n"
-    else:
-        stats_report += "Xatolar topilmadi yoki tahlil qilinmadi.\n"
-    
-    opening_report = "\n\n## 🎭 Debyut Statistikasi\n\n"
-    sorted_openings = sorted(opening_stats.items(), key=lambda x: x[1]['total'], reverse=True)[:10]
-    
-    for opening, stats in sorted_openings:
-        total = stats['total']
-        wins = stats['wins']
-        losses = stats['losses']
-        draws = stats['draws']
-        win_rate = (wins / total * 100) if total > 0 else 0
-        
-        opening_report += f"**{opening}** ({total} o'yin)\n"
-        opening_report += f"- G'alabalar: {wins} ({win_rate:.1f}%) | Yutqazishlar: {losses} | Duranglar: {draws}\n\n"
-    
-    color_report = "\n\n## ⚪⚫ Rang bo'yicha natijalar\n\n"
-    
-    white_total = sum(color_stats['white'].values())
-    black_total = sum(color_stats['black'].values())
-    
-    if white_total > 0:
-        white_wr = color_stats['white']['wins'] / white_total * 100
-        color_report += f"**Oq figuralar bilan:**\n"
-        color_report += f"- G'alabalar: {color_stats['white']['wins']} ({white_wr:.1f}%)\n"
-        color_report += f"- Yutqazishlar: {color_stats['white']['losses']}\n"
-        color_report += f"- Duranglar: {color_stats['white']['draws']}\n\n"
-    
-    if black_total > 0:
-        black_wr = color_stats['black']['wins'] / black_total * 100
-        color_report += f"**Qora figuralar bilan:**\n"
-        color_report += f"- G'alabalar: {color_stats['black']['wins']} ({black_wr:.1f}%)\n"
-        color_report += f"- Yutqazishlar: {color_stats['black']['losses']}\n"
-        color_report += f"- Duranglar: {color_stats['black']['draws']}\n"
-    
-    full_report = stats_report + opening_report + color_report
-    
-    ai_analysis = get_comprehensive_analysis(weaknesses, opening_stats, color_stats, len(games))
-    ai_report = f"## 🤖 AI Murabbiy: To'liq Tahlil va O'quv Rejasi\n\n{ai_analysis}"
-    
-    weakness_themes = [w['category'] for w in weaknesses[:3]]
-    puzzles = fetch_lichess_puzzles(weakness_themes, count=5)
-    
-    puzzle_text = "## 🧩 Sizning shaxsiy masalalaringiz\n\n"
-    puzzle_text += "Masalalarni yechish uchun quyidagi havoladan foydalaning:\n\n"
-    for i, puzzle in enumerate(puzzles, 1):
-        theme = puzzle.get('theme', 'Tactics')
-        url = puzzle.get('url', 'https://lichess.org/training')
-        puzzle_text += f"**Puzzle {i}: {theme}**\n"
-        puzzle_text += f"- [Lichess Training]({url})\n\n"
-    
-    return (
-        full_report,
-        ai_report,
-        puzzle_text,
-        "",
-        None,
-        "",
-        None,
-        "",
-        None
-    )
 
 with gr.Blocks(title="Chess Study Plan Pro", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""

config.py

@@ -1,97 +0,0 @@
-import os
-
-# ============= API SOZLAMALARI =============
-GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY', '')
-
-# ============= STOCKFISH SOZLAMALARI =============
-# Stockfish dasturining yo'lini kiriting
-# Windows: "C:/stockfish/stockfish.exe"
-# Linux/Mac: "/usr/local/bin/stockfish"
-STOCKFISH_PATH = os.environ.get('STOCKFISH_PATH', 'stockfish')
-STOCKFISH_DEPTH = 15  # Tahlil chuqurligi (15-20 yetarli)
-STOCKFISH_TIME = 0.1  # Har bir harakat uchun vaqt (sekundlarda)
-
-# ============= O'YIN SOZLAMALARI =============
-MAX_GAMES_TO_ANALYZE = 50  # Tahlil qilinadigan o'yinlar soni
-BLUNDER_THRESHOLD = 200  # Qo'pol xato chegarasi (santipawn)
-MISTAKE_THRESHOLD = 100  # Xato chegarasi (santipawn)
-
-# ============= CHESS.COM API =============
-CHESS_COM_API_BASE = "https://api.chess.com/pub"
-REQUEST_TIMEOUT = 10  # Sekundlarda
-
-# ============= LICHESS API =============
-LICHESS_API_BASE = "https://lichess.org/api"
-
-# ============= GEMINI PROMPT SHABLONLARI =============
-
-WEAKNESS_ANALYSIS_PROMPT = """Siz шахмат murabbiysiz. O'yinchi o'zining so'nggi o'yinlarida quyidagi zaif tomonlarni ko'rsatdi:
-
-{weakness_text}
-
-Har bir zaif tomonni oddiy va rag'batlantiruvchi tilda tushuntiring (har biri uchun 2-3 jumla). Yaxshilash uchun amaliy maslahatlar bering. Do'stona va motivatsion bo'ling.
-
-MUHIM: Javobni FAQAT O'ZBEK TILIDA yozing!"""
-
-MISTAKE_EXPLANATION_PROMPT = """Siz шахмат o'qituvchisisiz. O'yinchining quyidagi harakati tahlil qilindi:
-
-Harakat: {move}
-Pozitsiya: {position}
-Xato turi: {mistake_type}
-Baholash farqi: {eval_diff} santipawn
-
-Bu xatoni oddiy tilda tushuntiring va qanday qilib oldini olish mumkinligini aytib bering. 2-3 jumlada javob bering.
-
-MUHIM: Javobni FAQAT O'ZBEK TILIDA yozing!"""
-
-# ============= XATO KATEGORIYALARI =============
-
-MISTAKE_CATEGORIES = {
-    'blunder': 'Qo\'pol xatolar',
-    'mistake': 'Kichik xatolar',
-    'hanging_piece': 'Himoyasiz qoldirish',
-    'tactical_miss': 'Taktik imkoniyatni o\'tkazib yuborish',
-    'positional_error': 'Pozitsion xatolar',
-    'time_trouble': 'Vaqt muammolari',
-    'opening_mistake': 'Debyut xatolari',
-    'middlegame_mistake': 'O\'rta o\'yin xatolari',
-    'endgame_mistake': 'Endshpil xatolari'
-}
-
-# ============= INTERFACE MATNLARI =============
-
-UI_TEXTS = {
-    'title': '♟️ Shaxsiy Шахмат O\'quv Rejasi Generatori',
-    'description': """Chess.com foydalanuvchi nomingizni kiriting va quyidagilarni oling:
-    - 📊 Eng zaif 3 tomoningizni tahlil
-    - 🤖 AI murabbiy tushuntirishlari
-    - 🧩 Yaxshilash uchun 5 ta shaxsiy masala""",
-    'username_label': 'Chess.com foydalanuvchi nomi',
-    'username_placeholder': 'Foydalanuvchi nomini kiriting',
-    'analyze_button': '🔍 O\'yinlarni tahlil qilish',
-    'upload_pgn': '📁 PGN faylni yuklash',
-    'weakness_title': '📊 Zaif Tomonlar',
-    'explanation_title': '🤖 AI Murabbiy Tahlili',
-    'puzzles_title': '🧩 Sizning Shaxsiy O\'quv Rejangiz',
-    'instructions': """
-    ### 📝 Qanday foydalanish:
-    1. Chess.com foydalanuvchi nomingizni kiriting
-    2. "O'yinlarni tahlil qilish" tugmasini bosing
-    3. Dastur so'nggi 50 ta blitz o'yiningizni tahlil qiladi
-    4. Zaif tomonlaringiz va shaxsiy masalalarni ko'ring
-    
-    **Yoki** PGN faylni yuklashingiz mumkin
-    """
-}
-
-# ============= PUZZLE TEMALARI =============
-
-PUZZLE_THEMES = {
-    'blunder': 'mix',
-    'hanging_piece': 'hangingPiece',
-    'tactical_miss': 'fork,pin,skewer',
-    'positional_error': 'advantage',
-    'opening_mistake': 'opening',
-    'middlegame_mistake': 'middlegame',
-    'endgame_mistake': 'endgame'
-}

core/ai_integration.py

@@ -0,0 +1,65 @@
+
+
+import os
+from collections import defaultdict
+import logging
+import genai
+
+GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY')
+genai.configure(api_key=GEMINI_API_KEY)
+model = genai.GenerativeModel('gemini-2.0-flash-exp')
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def get_comprehensive_analysis(weaknesses, opening_stats, color_stats, total_games):
+    weakness_text = "\n".join([f"- {w['category']}: {w['count']} marta ({w['percentage']:.1f}%)" for w in weaknesses])
+    
+    opening_text = "\n".join([f"- {opening}: {stats['total']} o'yin (G'alabalar: {stats['wins']}, Yutqazishlar: {stats['losses']}, Duranglar: {stats['draws']})" 
+                              for opening, stats in list(opening_stats.items())[:5]])
+    
+    color_text = f"Oq rangda: {color_stats['white']['wins']}G-{color_stats['white']['losses']}Y-{color_stats['white']['draws']}D\n"
+    color_text += f"Qora rangda: {color_stats['black']['wins']}G-{color_stats['black']['losses']}Y-{color_stats['black']['draws']}D"
+    
+    prompt = f"""Siz professional шахмат murabbiy va tahlilchisiz. O'yinchining {total_games} ta o'yinini tahlil qildingiz.
+
+STATISTIKA:
+
+Zaif tomonlar:
+{weakness_text}
+
+Eng ko'p o'ynaladigan debyutlar:
+{opening_text}
+
+Rang bo'yicha natijalar:
+{color_text}
+
+Quyidagilarni taqdim eting:
+
+1. **ZAIF TOMONLAR TAHLILI**: Har bir zaif tomonni chuqur tahlil qiling va nima uchun bu muammo kelib chiqayotganini tushuntiring.
+
+2. **SHAXSIY O'QUV REJASI**: Kundalik mashg'ulotlar rejasini tuzing:
+   - Har kuni nechta masala yechish kerak va qanday turdagi masalalar
+   - Qaysi debyutlarni o'rganish kerak
+   - Qaysi o'yin bosqichiga ko'proq e'tibor berish kerak
+   - Kompyuter yoki botlar bilan qanday mashq qilish kerak
+
+3. **TAVSIYA ETILGAN RESURSLAR**:
+   - Kitoblar (muallif va nom bilan)
+   - Onlayn kurslar (Uzchess, Chess.com, Lichess)
+   - YouTube kanallari
+   - Mashq uchun maxsus botlar yoki dasturlar
+
+4. **DEBYUT TAVSIYALARI**: Statistikaga asoslanib, qaysi debyutlarni davom ettirish va qaysilarini o'zgartirish kerak.
+
+5. **MOTIVATSION XULOSA**: Qisqa va rag'batlantiruvchi xulosa.
+
+MUHIM: Javobni FAQAT O'ZBEK TILIDA yozing! Aniq va amaliy maslahatlar bering."""
+    
+    try:
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        logger.error(f"AI analysis failed: {str(e)}")
+        return f"AI tahlil hozircha mavjud emas: {str(e)}"

core/chess_api.py

@@ -0,0 +1,71 @@
+import logging
+import requests
+import time
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def get_user_games_from_chess_com(username):
+    try:
+        logger.info(f"Fetching games for: {username}")
+        username = username.strip().lower()
+        
+        user_url = f"https://api.chess.com/pub/player/{username}"
+        response = requests.get(user_url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
+        
+        if response.status_code != 200:
+            return None, f"❌ Foydalanuvchi topilmadi: {username}"
+        
+        archives_url = f"https://api.chess.com/pub/player/{username}/games/archives"
+        response = requests.get(archives_url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
+        
+        if response.status_code != 200:
+            return None, "❌ O'yinlar arxivi topilmadi."
+        
+        archives = response.json()['archives']
+        if not archives:
+            return None, "❌ O'yinlar topilmadi."
+        
+        all_games = []
+        for archive_url in reversed(archives[-3:]):
+            time.sleep(0.3)
+            response = requests.get(archive_url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
+            if response.status_code == 200:
+                games = response.json()['games']
+                all_games.extend(games)
+            if len(all_games) >= 50:
+                break
+        
+        rapid_games = [g for g in all_games if g.get('time_class') in ['rapid', 'blitz']]
+        if not rapid_games:
+            rapid_games = all_games[:50]
+        
+        pgn_list = [g['pgn'] for g in rapid_games[:50] if 'pgn' in g]
+        
+        if not pgn_list:
+            return None, "❌ PGN formatdagi o'yinlar topilmadi."
+        
+        return pgn_list, None
+        
+    except Exception as e:
+        logger.error(f"Error fetching games: {str(e)}")
+        return None, f"❌ Xatolik: {str(e)}"
+
+
+def fetch_lichess_puzzles(themes, count=5):
+    puzzles = []
+    
+    try:
+        url = "https://lichess.org/training"
+        for i in range(count):
+            puzzles.append({
+                'id': f'puzzle_{i+1}',
+                'url': url,
+                'theme': themes[0] if themes else 'Tactics',
+                'rating': 1500
+            })
+    except Exception as e:
+        logger.error(f"Error generating puzzle links: {str(e)}")
+    
+    return puzzles

core/core.py

@@ -0,0 +1,344 @@
+
+import chess
+import chess.pgn
+import io
+import re
+from collections import defaultdict
+from core.ai_integration import get_comprehensive_analysis
+from core.openings import detect_opening, load_opening_database
+from core.chess_api import get_user_games_from_chess_com, fetch_lichess_puzzles
+
+
+
+def analyze_games(username_chesscom, pgn_file, username_pgn):
+    actual_username = None
+    pgn_content = None
+
+    if username_chesscom:
+        pgn_content, error = get_user_games_from_chess_com(username_chesscom)
+        if error:
+            return error, "", "", "", None, None, None, None, None
+        actual_username = username_chesscom
+    
+    elif pgn_file:
+        pgn_content = pgn_file.decode('utf-8') if isinstance(pgn_file, bytes) else pgn_file
+        
+        if username_pgn and username_pgn.strip():
+            actual_username = username_pgn.strip()
+        else:
+            try:
+                first_game = chess.pgn.read_game(io.StringIO(pgn_content))
+                if first_game:
+                    white = first_game.headers.get("White", "")
+                    black = first_game.headers.get("Black", "")
+                    actual_username = white if white else black if black else "Player"
+                else:
+                    actual_username = "Player"
+            except:
+                actual_username = "Player"
+    
+    else:
+        return "❌ Chess.com foydalanuvchi nomini kiriting yoki PGN faylni yuklang", "", "", "", None, None, None, None, None
+
+    games = parse_pgn_content(pgn_content)
+    
+    if not games:
+        return "❌ O'yinlar topilmadi yoki tahlil qilinmadi", "", "", "", None, None, None, None, None
+    
+    all_analyses = []
+    opening_stats = defaultdict(lambda: {'wins': 0, 'losses': 0, 'draws': 0, 'total': 0})
+    color_stats = {
+        'white': {'wins': 0, 'losses': 0, 'draws': 0},
+        'black': {'wins': 0, 'losses': 0, 'draws': 0}
+    }
+    
+    for game in games:
+        analysis = analyze_game_detailed(game, actual_username)
+        all_analyses.append(analysis)
+        
+        opening = analysis['opening']
+        user_result = analysis.get('user_result')
+        user_color = analysis['user_color']
+        
+        if user_color is not None:
+            opening_stats[opening]['total'] += 1
+            
+            if user_result == 'win':
+                opening_stats[opening]['wins'] += 1
+                color_key = 'white' if user_color == chess.WHITE else 'black'
+                color_stats[color_key]['wins'] += 1
+            elif user_result == 'loss':
+                opening_stats[opening]['losses'] += 1
+                color_key = 'white' if user_color == chess.WHITE else 'black'
+                color_stats[color_key]['losses'] += 1
+            elif user_result == 'draw':
+                opening_stats[opening]['draws'] += 1
+                color_key = 'white' if user_color == chess.WHITE else 'black'
+                color_stats[color_key]['draws'] += 1
+    
+    weaknesses = categorize_mistakes(all_analyses)
+    
+    all_mistakes = []
+    for analysis in all_analyses:
+        all_mistakes.extend(analysis.get('mistakes', []))
+    
+    stats_report = f"## 📊 {len(games)} ta o'yin tahlili\n\n"
+    stats_report += f"**Jami xatolar:** {len(all_mistakes)} ta\n\n"
+    
+    stats_report += "### 🎯 Eng zaif 3 tomoningiz:\n\n"
+    if weaknesses:
+        for i, w in enumerate(weaknesses[:3], 1):
+            stats_report += f"**{i}. {w['category']}** - {w['count']} marta ({w['percentage']:.1f}%)\n"
+    else:
+        stats_report += "Xatolar topilmadi yoki tahlil qilinmadi.\n"
+    
+    opening_report = "\n\n## 🎭 Debyut Statistikasi\n\n"
+    sorted_openings = sorted(opening_stats.items(), key=lambda x: x[1]['total'], reverse=True)[:10]
+    
+    for opening, stats in sorted_openings:
+        total = stats['total']
+        wins = stats['wins']
+        losses = stats['losses']
+        draws = stats['draws']
+        win_rate = (wins / total * 100) if total > 0 else 0
+        
+        opening_report += f"**{opening}** ({total} o'yin)\n"
+        opening_report += f"- G'alabalar: {wins} ({win_rate:.1f}%) | Yutqazishlar: {losses} | Duranglar: {draws}\n\n"
+    
+    color_report = "\n\n## ⚪⚫ Rang bo'yicha natijalar\n\n"
+    
+    white_total = sum(color_stats['white'].values())
+    black_total = sum(color_stats['black'].values())
+    
+    if white_total > 0:
+        white_wr = color_stats['white']['wins'] / white_total * 100
+        color_report += f"**Oq figuralar bilan:**\n"
+        color_report += f"- G'alabalar: {color_stats['white']['wins']} ({white_wr:.1f}%)\n"
+        color_report += f"- Yutqazishlar: {color_stats['white']['losses']}\n"
+        color_report += f"- Duranglar: {color_stats['white']['draws']}\n\n"
+    
+    if black_total > 0:
+        black_wr = color_stats['black']['wins'] / black_total * 100
+        color_report += f"**Qora figuralar bilan:**\n"
+        color_report += f"- G'alabalar: {color_stats['black']['wins']} ({black_wr:.1f}%)\n"
+        color_report += f"- Yutqazishlar: {color_stats['black']['losses']}\n"
+        color_report += f"- Duranglar: {color_stats['black']['draws']}\n"
+    
+    full_report = stats_report + opening_report + color_report
+    
+    ai_analysis = get_comprehensive_analysis(weaknesses, opening_stats, color_stats, len(games))
+    ai_report = f"## 🤖 AI Murabbiy: To'liq Tahlil va O'quv Rejasi\n\n{ai_analysis}"
+    
+    weakness_themes = [w['category'] for w in weaknesses[:3]]
+    puzzles = fetch_lichess_puzzles(weakness_themes, count=5)
+    
+    puzzle_text = "## 🧩 Sizning shaxsiy masalalaringiz\n\n"
+    puzzle_text += "Masalalarni yechish uchun quyidagi havoladan foydalaning:\n\n"
+    for i, puzzle in enumerate(puzzles, 1):
+        theme = puzzle.get('theme', 'Tactics')
+        url = puzzle.get('url', 'https://lichess.org/training')
+        puzzle_text += f"**Puzzle {i}: {theme}**\n"
+        puzzle_text += f"- [Lichess Training]({url})\n\n"
+    
+    return (
+        full_report,
+        ai_report,
+        puzzle_text,
+        "",
+        None,
+        "",
+        None,
+        "",
+        None
+    )
+
+
+def parse_pgn_content(pgn_content):
+    games = []
+    if isinstance(pgn_content, list):
+        for pgn_text in pgn_content:
+            try:
+                game = chess.pgn.read_game(io.StringIO(pgn_text))
+                if game:
+                    games.append(game)
+            except:
+                pass
+    else:
+        pgn_io = io.StringIO(pgn_content)
+        while True:
+            try:
+                game = chess.pgn.read_game(pgn_io)
+                if game is None:
+                    break
+                games.append(game)
+            except:
+                break
+    
+    return games
+
+def analyze_game_detailed(game, username):
+    board = game.board()
+    mistakes = []
+    move_number = 0
+    
+    white_player = game.headers.get("White", "").strip().lower()
+    black_player = game.headers.get("Black", "").strip().lower()
+    username_lower = username.strip().lower()
+    
+    user_color = None
+    if username_lower == white_player:
+        user_color = chess.WHITE
+    elif username_lower == black_player:
+        user_color = chess.BLACK
+    
+    result = game.headers.get("Result", "*")
+    opening = detect_opening(game)
+    
+    user_result = None
+    if user_color is not None and result != "*":
+        if result == "1-0":
+            user_result = "win" if user_color == chess.WHITE else "loss"
+        elif result == "0-1":
+            user_result = "win" if user_color == chess.BLACK else "loss"
+        elif result == "1/2-1/2":
+            user_result = "draw"
+    
+    material_values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, chess.ROOK: 5, chess.QUEEN: 9}
+    
+    def count_material(board):
+        total = 0
+        for piece_type in material_values:
+            total += len(board.pieces(piece_type, chess.WHITE)) * material_values[piece_type]
+            total -= len(board.pieces(piece_type, chess.BLACK)) * material_values[piece_type]
+        return total
+    
+    for move in game.mainline_moves():
+        move_number += 1
+        
+        if user_color is not None and board.turn != user_color:
+            board.push(move)
+            continue
+        
+        material_before = count_material(board)
+        board.push(move)
+        material_after = count_material(board)
+        
+        material_loss = abs(material_after - material_before) if board.turn == chess.WHITE else abs(material_before - material_after)
+        
+        moved_piece = board.piece_at(move.to_square)
+        mistake_type = None
+        
+        if material_loss >= 3:
+            mistake_type = 'blunder'
+        elif material_loss >= 1:
+            mistake_type = 'mistake'
+        elif moved_piece and board.is_attacked_by(not board.turn, move.to_square):
+            attackers = len(board.attackers(not board.turn, move.to_square))
+            defenders = len(board.attackers(board.turn, move.to_square))
+            if attackers > defenders:
+                mistake_type = 'hanging_piece'
+        
+        if move_number <= 10:
+            phase = 'opening'
+        elif len(board.piece_map()) <= 10:
+            phase = 'endgame'
+        else:
+            phase = 'middlegame'
+        
+        if mistake_type:
+            mistakes.append({
+                'type': mistake_type,
+                'phase': phase,
+                'move_number': move_number
+            })
+    
+    return {
+        'mistakes': mistakes,
+        'opening': opening,
+        'result': result,
+        'user_color': user_color,
+        'user_result': user_result
+    }
+
+def categorize_mistakes(all_analyses):
+    if not all_analyses:
+        return []
+    
+    blunders = 0
+    regular_mistakes = 0
+    hanging = 0
+    opening = 0
+    middlegame = 0
+    endgame = 0
+    
+    for analysis in all_analyses:
+        for mistake in analysis.get('mistakes', []):
+            mistake_type = mistake.get('type')
+            phase = mistake.get('phase')
+            
+            if mistake_type == 'blunder':
+                blunders += 1
+            elif mistake_type == 'mistake':
+                regular_mistakes += 1
+            elif mistake_type == 'hanging_piece':
+                hanging += 1
+            
+            if phase == 'opening':
+                opening += 1
+            elif phase == 'middlegame':
+                middlegame += 1
+            elif phase == 'endgame':
+                endgame += 1
+    
+    total = blunders + regular_mistakes + hanging + opening + middlegame + endgame
+    
+    if total == 0:
+        return []
+    
+    weaknesses = []
+    
+    if blunders > 0:
+        weaknesses.append({
+            'category': "Qo'pol xatolar",
+            'count': blunders,
+            'percentage': (blunders / total * 100)
+        })
+    
+    if regular_mistakes > 0:
+        weaknesses.append({
+            'category': 'Kichik xatolar',
+            'count': regular_mistakes,
+            'percentage': (regular_mistakes / total * 100)
+        })
+    
+    if hanging > 0:
+        weaknesses.append({
+            'category': 'Himoyasiz qoldirish',
+            'count': hanging,
+            'percentage': (hanging / total * 100)
+        })
+    
+    if opening > 0:
+        weaknesses.append({
+            'category': 'Debyut xatolari',
+            'count': opening,
+            'percentage': (opening / total * 100)
+        })
+    
+    if middlegame > 0:
+        weaknesses.append({
+            'category': "O'rta o'yin xatolari",
+            'count': middlegame,
+            'percentage': (middlegame / total * 100)
+        })
+    
+    if endgame > 0:
+        weaknesses.append({
+            'category': 'Endshpil xatolari',
+            'count': endgame,
+            'percentage': (endgame / total * 100)
+        })
+    
+    weaknesses.sort(key=lambda x: x['count'], reverse=True)
+    
+    return weaknesses

core/openings.py

@@ -0,0 +1,32 @@
+
+import csv
+import logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def load_opening_database():
+    openings = {}
+    try:
+        with open('data/Chess Opening Reference - Sheet1.csv', 'r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                eco = row.get('ECO Code', '').strip()
+                name = row.get('Name', '').strip()
+                if eco and name:
+                    openings[eco] = name
+    except Exception as e:
+        logger.error(f"Failed to load openings CSV: {e}")
+    return openings
+
+OPENING_DB = load_opening_database()
+
+def detect_opening(game):
+    eco = game.headers.get("ECO", "")
+    opening = game.headers.get("Opening", "")
+    
+    if eco and eco in OPENING_DB:
+        return OPENING_DB[eco]
+    elif opening:
+        return opening
+    else:
+        return "Unknown Opening"

handlers.py

@@ -1,378 +0,0 @@
-import chess
-import chess.pgn
-import chess.engine
-import io
-import requests
-import google.generativeai as genai
-from collections import Counter
-import logging
-from datetime import datetime
-import time
-import config
-
-# Logging sozlash
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Gemini sozlash
-genai.configure(api_key=config.GEMINI_API_KEY)
-model = genai.GenerativeModel('gemini-2.0-flash-exp')
-
-# ============= CHESS.COM DAN O'YINLARNI OLISH =============
-
-def get_user_games(username):
-    """Chess.com dan foydalanuvchi o'yinlarini olish"""
-    logger.info(f"Foydalanuvchi o'yinlarini olish: {username}")
-    
-    try:
-        # Foydalanuvchini tekshirish
-        user_url = f"{config.CHESS_COM_API_BASE}/player/{username}"
-        logger.info(f"Foydalanuvchini tekshirish: {user_url}")
-        
-        response = requests.get(user_url, timeout=config.REQUEST_TIMEOUT)
-        if response.status_code != 200:
-            logger.error(f"Foydalanuvchi topilmadi: {username}")
-            return None, "❌ Foydalanuvchi topilmadi. Nomni tekshiring."
-        
-        logger.info(f"Foydalanuvchi topildi: {username}")
-        
-        # Arxivlarni olish
-        archives_url = f"{config.CHESS_COM_API_BASE}/player/{username}/games/archives"
-        logger.info(f"Arxivlarni olish: {archives_url}")
-        
-        response = requests.get(archives_url, timeout=config.REQUEST_TIMEOUT)
-        if response.status_code != 200:
-            logger.error("Arxivlar olinmadi")
-            return None, "❌ O'yinlar arxivi topilmadi."
-        
-        archives = response.json()['archives']
-        if not archives:
-            logger.warning("Arxivlar bo'sh")
-            return None, "❌ O'yinlar topilmadi."
-        
-        logger.info(f"Jami arxivlar: {len(archives)}")
-        
-        # So'nggi oylarning o'yinlarini olish
-        all_games = []
-        for archive_url in reversed(archives[-3:]):  # So'nggi 3 oy
-            logger.info(f"Arxivdan o'yinlarni olish: {archive_url}")
-            time.sleep(0.5)  # Rate limiting
-            
-            response = requests.get(archive_url, timeout=config.REQUEST_TIMEOUT)
-            if response.status_code == 200:
-                games = response.json()['games']
-                all_games.extend(games)
-                logger.info(f"Olindi: {len(games)} ta o'yin")
-            
-            if len(all_games) >= config.MAX_GAMES_TO_ANALYZE:
-                break
-        
-        # Blitz o'yinlarni filtrlash
-        blitz_games = [g for g in all_games if g.get('time_class') == 'blitz']
-        logger.info(f"Blitz o'yinlar: {len(blitz_games)}")
-        
-        if not blitz_games:
-            # Agar blitz bo'lmasa, bullet olish
-            bullet_games = [g for g in all_games if g.get('time_class') == 'bullet']
-            logger.info(f"Bullet o'yinlar: {len(bullet_games)}")
-            selected_games = bullet_games[:config.MAX_GAMES_TO_ANALYZE]
-        else:
-            selected_games = blitz_games[:config.MAX_GAMES_TO_ANALYZE]
-        
-        logger.info(f"Tanlangan o'yinlar: {len(selected_games)}")
-        
-        # PGN formatga o'tkazish
-        pgn_games = []
-        for game in selected_games:
-            if 'pgn' in game:
-                pgn_games.append(game['pgn'])
-        
-        logger.info(f"PGN formatdagi o'yinlar: {len(pgn_games)}")
-        
-        if not pgn_games:
-            return None, "❌ PGN formatdagi o'yinlar topilmadi."
-        
-        return pgn_games, None
-        
-    except Exception as e:
-        logger.error(f"Xatolik yuz berdi: {str(e)}")
-        return None, f"❌ Xatolik: {str(e)}"
-
-# ============= PGN TAHLIL =============
-
-def parse_pgn_games(pgn_list):
-    """PGN formatdagi o'yinlarni tahlil qilish"""
-    logger.info(f"PGN tahlil qilish: {len(pgn_list)} ta o'yin")
-    
-    games = []
-    for i, pgn_text in enumerate(pgn_list):
-        try:
-            pgn_io = io.StringIO(pgn_text)
-            game = chess.pgn.read_game(pgn_io)
-            if game:
-                games.append(game)
-                logger.info(f"O'yin {i+1} tahlil qilindi")
-        except Exception as e:
-            logger.error(f"O'yin {i+1} tahlil xatosi: {str(e)}")
-    
-    logger.info(f"Jami tahlil qilindi: {len(games)} ta o'yin")
-    return games
-
-# ============= STOCKFISH BILAN TAHLIL =============
-
-def analyze_game_with_engine(game, username):
-    """Stockfish yordamida o'yinni tahlil qilish"""
-    logger.info("Stockfish bilan tahlil boshlandi")
-    
-    try:
-        # Stockfish ni ishga tushirish
-        engine = chess.engine.SimpleEngine.popen_uci(config.STOCKFISH_PATH)
-        logger.info("Stockfish muvaffaqiyatli ishga tushdi")
-        
-        board = game.board()
-        mistakes = []
-        move_number = 0
-        
-        # Foydalanuvchi qaysi rangda o'ynaganini aniqlash
-        white_player = game.headers.get("White", "").lower()
-        black_player = game.headers.get("Black", "").lower()
-        user_color = None
-        
-        if username.lower() in white_player:
-            user_color = chess.WHITE
-            logger.info(f"Foydalanuvchi oq rangda: {username}")
-        elif username.lower() in black_player:
-            user_color = chess.BLACK
-            logger.info(f"Foydalanuvchi qora rangda: {username}")
-        
-        # Har bir harakatni tahlil qilish
-        for move in game.mainline_moves():
-            move_number += 1
-            
-            # Faqat foydalanuvchi harakatlarini tahlil qilish
-            if user_color is not None and board.turn != user_color:
-                board.push(move)
-                continue
-            
-            # Harakat oldin pozitsiyani baholash
-            try:
-                info_before = engine.analyse(
-                    board, 
-                    chess.engine.Limit(depth=config.STOCKFISH_DEPTH)
-                )
-                eval_before = info_before['score'].relative.score(mate_score=10000)
-                
-                # Harakatni qo'llash
-                board.push(move)
-                
-                # Harakat keyin pozitsiyani baholash
-                info_after = engine.analyse(
-                    board,
-                    chess.engine.Limit(depth=config.STOCKFISH_DEPTH)
-                )
-                eval_after = info_after['score'].relative.score(mate_score=10000)
-                
-                # Baholash farqini hisoblash (foydalanuvchi nuqtai nazaridan)
-                eval_diff = eval_before - eval_after
-                
-                # Xatolarni aniqlash
-                mistake_type = None
-                if eval_diff >= config.BLUNDER_THRESHOLD:
-                    mistake_type = 'blunder'
-                    logger.info(f"Qo'pol xato topildi: harakat {move_number}, farq {eval_diff}")
-                elif eval_diff >= config.MISTAKE_THRESHOLD:
-                    mistake_type = 'mistake'
-                    logger.info(f"Xato topildi: harakat {move_number}, farq {eval_diff}")
-                
-                if mistake_type:
-                    # Eng yaxshi harakatni topish
-                    best_move = info_before['pv'][0] if 'pv' in info_before else None
-                    
-                    mistakes.append({
-                        'move_number': move_number,
-                        'move': move.uci(),
-                        'best_move': best_move.uci() if best_move else None,
-                        'type': mistake_type,
-                        'eval_before': eval_before,
-                        'eval_after': eval_after,
-                        'eval_diff': eval_diff,
-                        'fen': board.fen(),
-                        'game_phase': get_game_phase(board)
-                    })
-                
-            except Exception as e:
-                logger.error(f"Harakat {move_number} tahlil xatosi: {str(e)}")
-                board.push(move)
-        
-        engine.quit()
-        logger.info(f"Tahlil tugadi. Topildi: {len(mistakes)} ta xato")
-        return mistakes
-        
-    except Exception as e:
-        logger.error(f"Stockfish xatosi: {str(e)}")
-        return []
-
-def get_game_phase(board):
-    """O'yin bosqichini aniqlash"""
-    move_count = board.fullmove_number
-    piece_count = len(board.piece_map())
-    
-    if move_count <= 10:
-        return 'opening_mistake'
-    elif piece_count <= 10:
-        return 'endgame_mistake'
-    else:
-        return 'middlegame_mistake'
-
-# ============= XATOLARNI KATEGORIYALASH =============
-
-def categorize_all_mistakes(all_mistakes):
-    """Barcha xatolarni kategoriyalash"""
-    logger.info(f"Kategoriyalash: {len(all_mistakes)} ta xato")
-    
-    # Xato turlarini sanash
-    mistake_types = []
-    for mistake in all_mistakes:
-        mistake_types.append(mistake['type'])
-        mistake_types.append(mistake['game_phase'])
-    
-    counts = Counter(mistake_types)
-    
-    # Eng ko'p uchragan 3 ta zaif tomonni topish
-    top_weaknesses = []
-    for mistake_type, count in counts.most_common(5):
-        if mistake_type in config.MISTAKE_CATEGORIES:
-            percentage = (count / len(all_mistakes) * 100) if all_mistakes else 0
-            top_weaknesses.append({
-                'category': config.MISTAKE_CATEGORIES[mistake_type],
-                'type': mistake_type,
-                'count': count,
-                'percentage': percentage
-            })
-    
-    logger.info(f"Eng ko'p zaif tomonlar: {len(top_weaknesses)}")
-    return top_weaknesses[:3]
-
-# ============= AI TUSHUNTIRISH =============
-
-def get_ai_explanation(weaknesses):
-    """Gemini dan tushuntirish olish"""
-    logger.info("AI tushuntirish olish")
-    
-    weakness_text = "\n".join([
-        f"- {w['category']}: {w['count']} marta ({w['percentage']:.1f}%)"
-        for w in weaknesses
-    ])
-    
-    prompt = config.WEAKNESS_ANALYSIS_PROMPT.format(weakness_text=weakness_text)
-    
-    try:
-        response = model.generate_content(prompt)
-        logger.info("AI javob olindi")
-        return response.text
-    except Exception as e:
-        logger.error(f"AI xatosi: {str(e)}")
-        return "AI tushuntirish hozircha mavjud emas."
-
-# ============= LICHESS DAN MASALALAR OLISH =============
-
-def fetch_puzzles_for_weaknesses(weaknesses, count=5):
-    """Zaif tomonlar uchun masalalar olish"""
-    logger.info(f"Masalalar olish: {count} ta")
-    
-    puzzles = []
-    
-    for weakness in weaknesses:
-        theme = config.PUZZLE_THEMES.get(weakness['type'], 'mix')
-        logger.info(f"Tema: {theme}")
-        
-        try:
-            # Lichess dan tasodifiy masala olish
-            url = f"{config.LICHESS_API_BASE}/puzzle/daily"
-            response = requests.get(url, timeout=config.REQUEST_TIMEOUT)
-            
-            if response.status_code == 200:
-                data = response.json()
-                puzzle = data['puzzle']
-                game = data['game']
-                
-                puzzles.append({
-                    'id': puzzle['id'],
-                    'fen': game['pgn'].split('\n')[-1],  # Oxirgi pozitsiya
-                    'rating': puzzle['rating'],
-                    'theme': weakness['category'],
-                    'solution': puzzle['solution'],
-                    'url': f"https://lichess.org/training/{puzzle['id']}"
-                })
-                logger.info(f"Masala olindi: {puzzle['id']}")
-        
-        except Exception as e:
-            logger.error(f"Masala olish xatosi: {str(e)}")
-    
-    # Yetarlicha bo'lmasa, standart masalalar qo'shish
-    while len(puzzles) < count:
-        puzzles.append({
-            'id': f'default_{len(puzzles)}',
-            'fen': 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1',
-            'rating': 1500,
-            'theme': 'Amaliyot',
-            'solution': ['e2e4'],
-            'url': 'https://lichess.org/training'
-        })
-    
-    logger.info(f"Jami masalalar: {len(puzzles)}")
-    return puzzles[:count]
-
-# ============= ASOSIY TAHLIL FUNKSIYASI =============
-
-def analyze_user_games(username):
-    """Foydalanuvchi o'yinlarini to'liq tahlil qilish"""
-    logger.info(f"===== TAHLIL BOSHLANDI: {username} =====")
-    
-    # 1. O'yinlarni olish
-    pgn_games, error = get_user_games(username)
-    if error:
-        logger.error(f"O'yinlar olinmadi: {error}")
-        return error, "", "", []
-    
-    # 2. PGN tahlil qilish
-    games = parse_pgn_games(pgn_games)
-    if not games:
-        logger.error("O'yinlar tahlil qilinmadi")
-        return "❌ O'yinlar tahlil qilinmadi.", "", "", []
-    
-    # 3. Har bir o'yinni Stockfish bilan tahlil qilish
-    all_mistakes = []
-    for i, game in enumerate(games[:10], 1):  # Birinchi 10 ta
-        logger.info(f"O'yin {i}/{len(games[:10])} tahlil qilinmoqda...")
-        mistakes = analyze_game_with_engine(game, username)
-        all_mistakes.extend(mistakes)
-    
-    if not all_mistakes:
-        logger.info("Xatolar topilmadi")
-        return "✅ Ajoyib! Sizning o'yinlaringizda katta xatolar topilmadi!", "", "", []
-    
-    # 4. Zaif tomonlarni aniqlash
-    weaknesses = categorize_all_mistakes(all_mistakes)
-    
-    # 5. Hisobot tayyorlash
-    report = f"## 📊 {len(games)} ta o'yin tahlili\n\n"
-    report += f"**Topilgan xatolar:** {len(all_mistakes)} ta\n\n"
-    report += "### 🎯 Sizning eng zaif 3 tomoningiz:\n\n"
-    
-    for i, w in enumerate(weaknesses, 1):
-        report += f"**{i}. {w['category']}**\n"
-        report += f"   - {w['count']} marta ({w['percentage']:.1f}%)\n\n"
-    
-    # 6. AI tushuntirish
-    explanation = get_ai_explanation(weaknesses)
-    explanation_text = f"## 🤖 AI Murabbiy Tahlili\n\n{explanation}"
-    
-    # 7. Masalalar olish
-    puzzles = fetch_puzzles_for_weaknesses(weaknesses, count=5)
-    
-    logger.info("===== TAHLIL TUGADI =====")
-    return report, explanation_text, "", puzzles

openings.py

@@ -1,82 +0,0 @@
-
-def get_opening_name_from_eco(eco_code):
-    eco_openings = {
-        'A00': 'Uncommon Opening',
-        'A01': "Nimzowitsch-Larsen Attack",
-        'A02': "Bird's Opening",
-        'A03': "Bird's Opening: Dutch Variation",
-        'A04': 'Reti Opening',
-        'A05': 'Reti Opening: 1...Nf6',
-        'A06': 'Reti Opening: 2.b3',
-        'A10': 'English Opening',
-        'A15': 'English Opening: Anglo-Indian Defense',
-        'A20': 'English Opening: 1...e5',
-        'A30': 'English Opening: Symmetrical Variation',
-        "A34": "English Opening: Botvinnik System",
-        "A36": "English Opening: King's English Variation",
-        'A40': 'Queen Pawn Game',
-        'A45': 'Indian Defense',
-        'A46': 'Indian Defense: 2.Nf3',
-        'A50': 'Indian Defense: Normal Variation',
-        'B00': 'Uncommon King Pawn Opening',
-        'B01': 'Scandinavian Defense',
-        'B02': "Alekhine's Defense",
-        'B03': "Alekhine's Defense: Four Pawns Attack",
-        'B10': 'Caro-Kann Defense',
-        'B12': 'Caro-Kann Defense: Advance Variation',
-        "B13": 'Caro-Kann Defense: Classical Variation',
-        "B14": 'Caro-Kann Defense: Panov-Botvinnik Attack',
-        "B15": 'Caro-Kann Defense: Panov-Botvinnik Attack',
-        'B20': 'Sicilian Defense',
-        'B22': 'Sicilian Defense: Alapin Variation',
-        'B23': 'Sicilian Defense: Closed',
-        'B30': 'Sicilian Defense: 2...Nc6',
-        "B32": 'Sicilian Defense: Hyperaccelerated Dragon',
-        'B40': 'Sicilian Defense: French Variation',
-        'B50': 'Sicilian Defense: 2...d6',
-        'B90': 'Sicilian Defense: Najdorf',
-        'C00': 'French Defense',
-        "C01": 'French Defense: Exchange Variation',
-        'C02': 'French Defense: Advance Variation',
-        'C10': 'French Defense: Rubinstein Variation',
-        'C20': 'King Pawn Game',
-        'C30': "King's Gambit",
-        'C40': "King's Knight Opening",
-        'C41': 'Philidor Defense',
-        'C42': 'Russian Game (Petrov Defense)',
-        'C44': 'Scotch Game',
-        'C50': 'Italian Game',
-        "C54": "Italian Game: Giuoco Piano",
-        'C55': 'Italian Game: Two Knights Defense',
-        'C60': 'Spanish Opening (Ruy Lopez)',
-        'C65': 'Spanish Opening: Berlin Defense',
-        'C70': 'Spanish Opening',
-        'C78': 'Spanish Opening: Morphy Defense',
-        'C80': 'Spanish Opening: Open Variation',
-        'D00': 'Queen Pawn Game',
-        'D02': 'Queen Pawn Game: 2.Nf3',
-        'D10': 'Slav Defense',
-        'D20': "Queen's Gambit Accepted",
-        'D30': "Queen's Gambit Declined",
-        'D50': "Queen's Gambit Declined: 4.Bg5",
-        'E00': 'Indian Defense',
-        'E10': 'Indian Defense: 3.Nf3',
-        'E20': 'Nimzo-Indian Defense',
-        'E30': 'Nimzo-Indian Defense: Leningrad Variation',
-        'E60': "King's Indian Defense",
-        'E70': "King's Indian Defense: Normal Variation",
-        'E90': "King's Indian Defense: Orthodox Variation",
-    }
-    
-    return eco_openings.get(eco_code, f"Opening ECO {eco_code}")
-
-def detect_opening(game):
-    opening = game.headers.get("Opening", "")
-    eco = game.headers.get("ECO", "")
-    
-    if opening:
-        return opening
-    elif eco:
-        return get_opening_name_from_eco(eco)
-    else:
-        return "Unknown Opening"

project_info.md

@@ -0,0 +1,48 @@
+# ♟️ Chess Study Plan Pro - Professional Shaxmat O'quv Rejasi
+
+![Chess AI](https://img.shields.io/badge/Chess-AI%20Powered-blue)
+![Python](https://img.shields.io/badge/Python-3.8+-green)
+![Gradio](https://img.shields.io/badge/Gradio-UI-orange)
+
+## 📋 Loyiha Haqida
+
+**Chess Study Plan Pro** - bu shaxmatchilar uchun sun'iy intellekt asosida ishlaydigan professional tahlil va o'quv rejasi yaratuvchi dastur. Loyiha UzChess AI Hackaton uchun ishlab chiqilgan bo'lib, shaxmatchilarning o'yin uslubini chuqur tahlil qilib, shaxsiy rivojlanish rejasini taklif etadi.
+
+### 🎯 Asosiy Maqsad
+
+Har bir shaxmatchi o'zining zaif tomonlarini bilishi va ularni yaxshilash uchun aniq yo'l-yo'riq olishi kerak. Ushbu dastur aynan shu muammoni hal qiladi - o'yinlaringizni tahlil qilib, sizga maxsus o'quv rejasini tayyorlaydi.
+
+## ✨ Asosiy Imkoniyatlar
+
+### 🔍 To'liq O'yin Tahlili
+- **Xatolarni aniqlash**: Qo'pol xatolar, kichik xatolar va himoyasiz qoldirishlarni topadi
+- **Fazalar bo'yicha tahlil**: Debyut, o'rta o'yin va endshpil bo'yicha alohida statistika
+- **Material yo'qotishlar**: Har bir xatoda qancha material yo'qotganingizni hisoblaydi
+
+### 📊 Batafsil Statistika
+- **Debyut tahlili**: Qaysi debyutlarda yaxshi/yomon natijalar ko'rsatasiz
+- **Rang statistikasi**: Oq va qora figuralar bilan alohida natijalar
+- **G'alaba foizi**: Har bir debyut va rang uchun g'alaba foizi
+- **O'yinlar soni**: 50 tagacha oxirgi o'yinlarni tahlil qiladi
+
+### 🤖 AI Murabbiy (Gemini 2.0)
+- **Zaif tomonlar tahlili**: Nima uchun xatolar sodir bo'layotganini tushuntiradi
+- **Kundalik o'quv rejasi**: Har kuni necha masala yechish, qaysi debyutlarni o'rganish
+- **Resurslar tavsiyasi**: Kitoblar, kurslar, YouTube kanallari
+- **Motivatsion maslahatlar**: Psixologik qo'llab-quvvatlash
+
+### 🧩 Mashq Masalalari
+- Zaif tomonlaringizga mos Lichess masalalari havolalari
+- Har bir muammo uchun maxsus tanlangan mashqlar
+- To'g'ridan-to'g'ri Lichess Training bo'limiga yo'naltirish
+
+## 🚀 O'rnatish va Ishga Tushirish
+
+### Talablar
+```bash
+Python 3.8+
+gradio
+chess
+requests
+google-generativeai
+O'rnatish