Upload 19 files

README.md

@@ -9,7 +9,7 @@ pinned: false
 
 # 🤖 ITMO Магистратура - Чат-бот
 
-Полноценный чат-бот для абитуриентов магистратур ITMO с LLM-генерацией ответов и персональными рекомендациями.
+Полноценный чат-бот для абитуриентов магистратур ITMO с LLM-генерацией ответов, парсингом реальных данных и персональными рекомендациями.
 
 ## 🚀 Быстрый деплой в HF Spaces
 
@@ -28,17 +28,30 @@ pinned: false
 
 ### 3. Автоматический запуск
 - HF Spaces автоматически соберет Docker образ
-- При первом запуске загрузятся модели и создадутся данные
+- При первом запуске загрузятся модели и спарсятся данные с сайтов ITMO
 - Приложение будет доступно по URL вида: `https://huggingface.co/spaces/username/space-name`
 
 ## 🎯 Возможности
 
 - **LLM-генерация ответов**: cointegrated/rut5-base-multitask для естественных ответов
 - **RAG поиск**: SentenceTransformer + FAISS для точного поиска по курсам
-- **Персональные рекомендации**: на основе профиля студента с LLM-объяснениями
+- **Парсинг реальных данных**: автоматический сбор с сайтов ITMO
+- **LLM-рекомендации**: персонализированные советы с объяснениями
 - **Фильтр релевантности**: отвечает только на вопросы о ITMO
 - **Улучшенный UI**: навыки, интересы, ползунки для оценки уровня
 
+## 📊 Источники данных
+
+### Автоматический парсинг:
+- **https://abit.itmo.ru/program/master/ai** - программа "Искусственный интеллект"
+- **https://abit.itmo.ru/program/master/ai_product** - программа "AI Product Management"
+
+### Извлекаемые данные:
+- Заголовки и описания программ
+- Ссылки на PDF учебные планы
+- Парсинг PDF с извлечением курсов
+- Нормализация и обогащение данных
+
 ## ⚙️ Быстрые настройки
 
 ### Параметры производительности (CPU basic):
@@ -57,7 +70,7 @@ max_text_length = 220          # Максимум символов для эмб
 - **CPU**: 2 vCPU
 - **RAM**: до 16GB
 - **Диск**: 50GB ephemeral
-- **Время холодного старта**: до 3 минут (загрузка моделей)
+- **Время холодного старта**: до 3 минут (загрузка моделей + парсинг)
 
 ## 🔧 Локальный запуск
 
@@ -89,12 +102,34 @@ python app.py
 - **Чат**: системные инструкции + контекст + история + вопрос
 - **Рекомендации**: профиль студента + доступные курсы + инструкции по выбору
 
+### Парсинг данных:
+- **HTML скрапинг**: BeautifulSoup для извлечения метаданных программ
+- **PDF парсинг**: pdfplumber для извлечения курсов из учебных планов
+- **Нормализация**: унификация форматов и обогащение тегами
+- **Обновления**: проверка изменений на сайтах ITMO
+
 ### Оптимизации:
 - Ленивая загрузка моделей
 - Кэширование данных на диске
 - Fallback режим при ошибках
 - Компактные эмбеддинги (float32, ≤220 символов)
 
+## 🔄 Обновление данных
+
+### Автоматическое обновление:
+- При первом запуске парсится актуальная информация с сайтов ITMO
+- Проверка обновлений при каждом запуске
+- Кнопка "Обновить данные" для принудительного обновления
+
+### Ручное обновление:
+```bash
+# Принудительное обновление
+python update_data.py --force
+
+# Проверка обновлений
+python update_data.py --check
+```
+
 ## 🔍 Устранение неполадок
 
 ### Проблемы с памятью:
@@ -106,8 +141,14 @@ top_k = 4                 # Уменьшить с 6
 ### Проблемы с холодным стартом:
 - Первый запуск может занять 2-3 минуты
 - Модели загружаются при первом обращении
+- Парсинг данных выполняется автоматически
 - Последующие запуски используют кэш
 
+### Проблемы с парсингом:
+- При недоступности сайтов ITMO используются тестовые данные
+- Проверьте интернет-соединение
+- Логи показывают детали процесса парсинга
+
 ### Проблемы с Docker:
 - Убедитесь, что Dockerfile корректный
 - Проверьте логи сборки в HF Spaces
@@ -115,4 +156,4 @@ top_k = 4                 # Уменьшить с 6
 
 ---
 
-**Примечание**: Бот работает с тестовыми данными для быстрого старта. Для реальных данных используйте кнопку "Обновить данные".
+**Примечание**: Бот автоматически парсит актуальные данные с сайтов ITMO. При недоступности источников используются тестовые данные для демонстрации функциональности.

app.py

@@ -21,9 +21,15 @@ def chat_with_bot(message, history):
     
     try:
         response, relevance_score = chatbot.chat(message, history)
+        
+        # Проверяем, что ответ не пустой и не содержит технических деталей
+        if not response or response.startswith('[') or len(response.strip()) < 5:
+            response = 'К сожалению, не смог сгенерировать ответ. Попробуйте переформулировать вопрос.'
+        
         return history + [[message, response]], ''
     except Exception as e:
-        error_msg = f'Произошла ошибка: {str(e)}'
+        print(f'Ошибка в чате: {e}')
+        error_msg = 'Произошла ошибка при обработке запроса. Попробуйте еще раз.'
         return history + [[message, error_msg]], ''
 
 def get_recommendations(programming_exp, math_level, interests, semester, skills):
@@ -43,9 +49,16 @@ def get_recommendations(programming_exp, math_level, interests, semester, skills
             'interests': all_interests,
             'semester': semester
         }
+        
         recommendations = chatbot.recommend_courses(profile)
+        
+        # Проверяем качество ответа
+        if not recommendations or recommendations.startswith('[') or len(recommendations.strip()) < 10:
+            recommendations = 'К сожалению, не удалось сгенерировать рекомендации. Попробуйте изменить параметры профиля.'
+        
         return recommendations
     except Exception as e:
+        print(f'Ошибка в рекомендациях: {e}')
         return f'Ошибка при получении рекомендаций: {str(e)}'
 
 def update_data_ui():

app_simple.py

@@ -106,11 +106,15 @@ def chat_with_bot(message, history):
     
     return history + [[message, response]], ''
 
-def get_recommendations(programming_exp, math_level, interests, semester):
+def get_recommendations(programming_exp, math_level, interests, semester, skills):
     if not semester:
         return 'Пожалуйста, укажите семестр для получения рекомендаций.'
     
-    semester = int(semester)
+    try:
+        semester = int(semester)
+    except ValueError:
+        return 'Пожалуйста, выберите корректный семестр.'
+    
     filtered_courses = [c for c in TEST_COURSES if c['semester'] == semester]
     
     if not filtered_courses:
@@ -119,22 +123,45 @@ def get_recommendations(programming_exp, math_level, interests, semester):
     # Простая логика рекомендаций
     recommendations = []
     for course in filtered_courses[:5]:  # Топ-5 курсов
-        why = 'Курс из учебного плана программы'
-        if interests:
-            matching_tags = [tag for tag in interests if tag in course.get('tags', [])]
-            if matching_tags:
-                why = f'Соответствует вашим интересам: {", ".join(matching_tags)}'
+        score = 0
+        why_reasons = []
+        
+        # Оценка по интересам
+        all_interests = interests + skills
+        matching_tags = [tag for tag in all_interests if tag in course.get('tags', [])]
+        if matching_tags:
+            score += 2
+            why_reasons.append(f'соответствует вашим интересам: {", ".join(matching_tags)}')
+        
+        # Оценка по опыту программирования
+        if programming_exp >= 3 and any(tag in course.get('tags', []) for tag in ['ml', 'dl', 'systems']):
+            score += 1
+            why_reasons.append('подходит для вашего уровня программирования')
         
-        recommendations.append({
-            'name': course['name'],
-            'semester': course['semester'],
-            'credits': course['credits'],
-            'why': why
-        })
+        # Оценка по математике
+        if math_level >= 3 and any(tag in course.get('tags', []) for tag in ['math', 'stats', 'dl']):
+            score += 1
+            why_reasons.append('соответствует вашему уровню математики')
+        
+        if score > 0:
+            recommendations.append({
+                'name': course['name'],
+                'credits': course['credits'],
+                'why': '; '.join(why_reasons) if why_reasons else 'курс из учебного плана программы'
+            })
+    
+    if not recommendations:
+        # Если нет подходящих, показываем все курсы
+        for course in filtered_courses[:3]:
+            recommendations.append({
+                'name': course['name'],
+                'credits': course['credits'],
+                'why': 'курс из учебного плана программы'
+            })
     
-    result = '🎯 Рекомендуемые курсы (из официальных учебных планов ITMO):\n\n'
+    result = f'🎯 Рекомендуемые курсы для {semester} семестра:\n\n'
     for i, rec in enumerate(recommendations, 1):
-        result += f'{i}. {rec["name"]} ({rec["semester"]} семестр, {rec["credits"]} кредитов)\n'
+        result += f'{i}. {rec["name"]} ({rec["credits"]} кредитов)\n'
         result += f'   {rec["why"]}\n\n'
     
     return result
@@ -166,25 +193,35 @@ with gr.Blocks(title='ITMO Магистратура - Чат-бот', theme=gr.t
         with gr.Column(scale=1):
             gr.Markdown('### 👤 Профиль для рекомендаций')
             
-            programming_exp = gr.Slider(
-                minimum=0, maximum=5, value=2, step=1,
-                label='Опыт программирования (0-5)',
-                info='0 - нет опыта, 5 - эксперт'
-            )
-            
-            math_level = gr.Slider(
-                minimum=0, maximum=4, value=2, step=1,
-                label='Уровень математики (0-4)',
-                info='0 - базовый, 4 - продвинутый'
-            )
+            with gr.Row():
+                programming_exp = gr.Slider(
+                    minimum=0, maximum=5, value=2, step=1,
+                    label='Опыт программирования (0-5)',
+                    info='0 - нет опыта, 5 - эксперт'
+                )
+                
+                math_level = gr.Slider(
+                    minimum=0, maximum=4, value=2, step=1,
+                    label='Уровень математ��ки (0-4)',
+                    info='0 - базовый, 4 - продвинутый'
+                )
             
+            gr.Markdown('**Интересы:**')
             interests = gr.CheckboxGroup(
                 choices=['ml', 'dl', 'nlp', 'cv', 'product', 'business', 'research', 'data', 'systems'],
                 value=['ml'],
-                label='Интересы',
+                label='Области интересов',
                 info='Выберите интересующие направления'
             )
             
+            gr.Markdown('**Навыки:**')
+            skills = gr.CheckboxGroup(
+                choices=['python', 'java', 'sql', 'git', 'docker', 'aws', 'tensorflow', 'pytorch', 'scikit-learn'],
+                value=['python'],
+                label='Технические навыки',
+                info='Выберите имеющиеся навыки'
+            )
+            
             semester = gr.Dropdown(
                 choices=['1', '2', '3', '4'],
                 label='Целевой семестр',
@@ -194,13 +231,13 @@ with gr.Blocks(title='ITMO Магистратура - Чат-бот', theme=gr.t
             recommend_btn = gr.Button('🎯 Получить рекомендации', variant='primary')
             recommendations_output = gr.Textbox(
                 label='Рекомендации',
-                lines=10,
+                lines=12,
                 interactive=False
             )
             
             recommend_btn.click(
                 get_recommendations,
-                inputs=[programming_exp, math_level, interests, semester],
+                inputs=[programming_exp, math_level, interests, semester, skills],
                 outputs=recommendations_output
             )
     

chatbot.py

@@ -57,6 +57,11 @@ class ITMOChatbot:
         if not semester:
             return 'Пожалуйста, укажите семестр для получения рекомендаций.'
         
+        try:
+            semester = int(semester)
+        except ValueError:
+            return 'Пожалуйста, выберите корректный семестр.'
+        
         # Получение курсов для семестра
         courses = self.knowledge_base.get_courses_by_semester(semester)
         
@@ -70,11 +75,18 @@ class ITMOChatbot:
     
     def _get_context(self, message: str) -> List[Dict]:
         try:
-            results = self.retriever.retrieve(message, k=6, threshold=0.35)
-            return results
+            # Сначала пробуем RAG поиск
+            if self.retriever.index:
+                results = self.retriever.retrieve(message, k=6, threshold=0.35)
+                if results:
+                    return results
+            
+            # Fallback на простой поиск
+            return self.knowledge_base.search_courses(message)
+            
         except Exception as e:
             print(f'Ошибка получения контекста: {e}')
-            return []
+            return self.knowledge_base.search_courses(message)
     
     def _generate_answer(self, message: str, context: List[Dict], history: List[List[str]]) -> str:
         if not self.generator:
@@ -87,7 +99,7 @@ class ITMOChatbot:
             # Генерация ответа
             response = self.generator(
                 prompt,
-                max_new_tokens=180,
+                max_new_tokens=200,
                 temperature=0.4,
                 do_sample=True,
                 pad_token_id=self.generator.tokenizer.eos_token_id
@@ -98,8 +110,14 @@ class ITMOChatbot:
             # Очистка ответа
             if answer.startswith('Ответ:'):
                 answer = answer[6:].strip()
+            elif answer.startswith('Бот:'):
+                answer = answer[4:].strip()
             
-            return answer if answer else self._fallback_answer(context)
+            # Проверяем, что ответ не пустой и не содержит технических деталей
+            if answer and len(answer) > 10 and not answer.startswith('['):
+                return answer
+            else:
+                return self._fallback_answer(context)
             
         except Exception as e:
             print(f'Ошибка генерации ответа: {e}')
@@ -116,7 +134,7 @@ class ITMOChatbot:
             # Генерация рекомендаций
             response = self.generator(
                 prompt,
-                max_new_tokens=300,
+                max_new_tokens=400,
                 temperature=0.5,
                 do_sample=True,
                 pad_token_id=self.generator.tokenizer.eos_token_id
@@ -128,7 +146,11 @@ class ITMOChatbot:
             if recommendations.startswith('Рекомендации:'):
                 recommendations = recommendations[14:].strip()
             
-            return recommendations if recommendations else self._fallback_recommendations(profile, courses)
+            # Проверяем качество ответа
+            if recommendations and len(recommendations) > 20 and not recommendations.startswith('['):
+                return recommendations
+            else:
+                return self._fallback_recommendations(profile, courses)
             
         except Exception as e:
             print(f'Ошибка генерации рекомендаций: {e}')
@@ -136,7 +158,7 @@ class ITMOChatbot:
     
     def _build_prompt(self, message: str, context: List[Dict], history: List[List[str]]) -> str:
         # Системные инструкции
-        system_prompt = '''Отвечай только по контексту (ниже). Если недостаточно данных — прямо скажи: 'в предоставленных данных об этом не сказано'. Отвечай кратко и по делу.'''
+        system_prompt = '''Ты - помощник для абитуриентов магистратур ITMO. Отвечай на вопросы о программах и курсах на основе предоставленного контекста. Отвечай кратко, дружелюбно и по делу. Если информации недостаточно, скажи об этом прямо.'''
         
         # История диалога (последние 3 хода)
         history_text = ''
@@ -146,13 +168,15 @@ class ITMOChatbot:
                 history_text += f'Пользователь: {user_msg}\nБот: {bot_msg}\n\n'
         
         # Контекст
-        context_text = 'Контекст:\n'
+        context_text = 'Информация о курсах:\n'
         for i, item in enumerate(context, 1):
             context_text += f'{i}. {item["name"]} ({item["semester"]} семестр, {item["credits"]} кредитов)\n'
-            context_text += f'   {item["short_desc"]}\n\n'
+            if item.get('short_desc'):
+                context_text += f'   {item["short_desc"]}\n'
+            context_text += '\n'
         
         # Полный промпт
-        full_prompt = f'{system_prompt}\n\n{history_text}{context_text}Вопрос: {message}\nОтвет:'
+        full_prompt = f'{system_prompt}\n\n{history_text}{context_text}Пользователь: {message}\nБот:'
         
         return full_prompt
     
@@ -171,13 +195,14 @@ class ITMOChatbot:
         for i, course in enumerate(courses[:10], 1):  # Топ-10 курсов
             tags = ', '.join(course.get('tags', []))
             courses_text += f'{i}. {course["name"]} ({course["credits"]} кредитов)\n'
-            courses_text += f'   Описание: {course["short_desc"]}\n'
+            if course.get('short_desc'):
+                courses_text += f'   Описание: {course["short_desc"]}\n'
             courses_text += f'   Теги: {tags}\n\n'
         
         # Инструкции для рекомендаций
         instructions = '''Для такого студента с такими навыками какие из курсов подойдут? 
 Выбери 3-5 наиболее подходящих курсов и объясни почему они подходят для этого профиля.
-Учитывай уровень сложности, интересы и опыт студента.'''
+Учитывай уровень сложности, интересы и опыт студента. Отвечай на русском языке.'''
         
         full_prompt = f'{profile_text}\n\n{courses_text}\n{instructions}\n\nРекомендации:'
         
@@ -190,27 +215,55 @@ class ITMOChatbot:
         response = 'Найденная информация:\n\n'
         for i, item in enumerate(context, 1):
             response += f'{i}. {item["name"]} ({item["semester"]} семестр, {item["credits"]} кредитов)\n'
-            response += f'   {item["short_desc"]}\n\n'
+            if item.get('short_desc'):
+                response += f'   {item["short_desc"]}\n'
+            response += '\n'
         
         return response
     
     def _fallback_recommendations(self, profile: Dict, courses: List[Dict]) -> str:
         semester = profile.get('semester')
         interests = profile.get('interests', [])
+        programming_exp = profile.get('programming_experience', 2)
+        math_level = profile.get('math_level', 2)
         
         # Простая логика рекомендаций
         recommendations = []
         for course in courses[:5]:
+            score = 0
+            why_reasons = []
+            
+            # Оценка по интересам
             matching_tags = [tag for tag in interests if tag in course.get('tags', [])]
-            why = 'Курс из учебного плана программы'
             if matching_tags:
-                why = f'Соответствует вашим интересам: {", ".join(matching_tags)}'
+                score += 2
+                why_reasons.append(f'соответствует вашим интересам: {", ".join(matching_tags)}')
+            
+            # Оценка по опыту программирования
+            if programming_exp >= 3 and any(tag in course.get('tags', []) for tag in ['ml', 'dl', 'systems']):
+                score += 1
+                why_reasons.append('подходит для вашего уровня программирования')
             
-            recommendations.append({
-                'name': course['name'],
-                'credits': course['credits'],
-                'why': why
-            })
+            # Оценка по математике
+            if math_level >= 3 and any(tag in course.get('tags', []) for tag in ['math', 'stats', 'dl']):
+                score += 1
+                why_reasons.append('соответствует вашему уровню математики')
+            
+            if score > 0:
+                recommendations.append({
+                    'name': course['name'],
+                    'credits': course['credits'],
+                    'why': '; '.join(why_reasons) if why_reasons else 'курс из учебного плана программы'
+                })
+        
+        if not recommendations:
+            # Если нет подходящих, показываем все курсы
+            for course in courses[:3]:
+                recommendations.append({
+                    'name': course['name'],
+                    'credits': course['credits'],
+                    'why': 'курс из учебного плана программы'
+                })
         
         result = f'🎯 Рекомендуемые курсы для {semester} сем��стра:\n\n'
         for i, rec in enumerate(recommendations, 1):

data/processed/programs.json

@@ -2,29 +2,57 @@
   "ai": {
     "id": "ai",
     "title": "Искусственный интеллект",
-    "description": "Магистерская программа по искусственному интеллекту в ITMO",
+    "description": "Основа обучения на программе – проектный подход. Магистранты работают над проектами ведущих компаний — X5 Group, Ozon Банк, МТС, Sber AI, Норникель, Napoleon IT, Genotek, Raft, AIRI, DeepPavlov. Перенимают опыт у 20+ экспертов в ML, в том числе из Яндекса и Газпромбанка. Вы станете частью комьюнити ведущих специалистов в области AI и ML.Вы сможете составить персональную траекторию обучения из курсов и проектов и освоить одну или несколько ролей: ML Engineer, Data Engineer, AI Product Developer и...",
     "url": "https://abit.itmo.ru/program/master/ai",
     "pdf_links": [
       {
-        "url": "https://abit.itmo.ru/program/master/ai/curriculum",
-        "text": "учебный план",
-        "filename": "ai_curriculum.pdf"
+        "url": "https://abit.itmo.ru/file_storage/file/exams/master/ai.pdf",
+        "filename": "document_ai.pdf",
+        "type": "document",
+        "text": "смотреть"
+      },
+      {
+        "url": "https://itmo.ru/file/pages/79/personal_data_policy.pdf",
+        "filename": "document_personal_data_policy.pdf",
+        "type": "document",
+        "text": "политика по обработке персональных данных"
+      },
+      {
+        "url": "https://itmo.ru/images/pages/79/Pravila_ispolzovanija_informacii.pdf",
+        "filename": "document_Pravila_ispolzovanija_informacii.pdf",
+        "type": "document",
+        "text": "правила использования информации в доменной зоне itmo.ru"
       }
     ],
-    "hash": "test_hash_ai"
+    "content_hash": "525fb9a55baee4c11803c49ab1814e1b59fe3ed76715b120888241528e2671d2",
+    "last_updated": ""
   },
   "ai_product": {
     "id": "ai_product",
-    "title": "AI Product",
-    "description": "Магистерская программа по продуктовой разработке с ИИ",
+    "title": "Управление ИИ-продуктами/AI Product",
+    "description": "Программа дает глубокие технические знания в области разработки систем искусственного интеллекта и навыки продуктового менеджмента. Вы сможете создавать инновационные ИИ‑решения и выводить их на рынок. Широкий выбор предметов позволяет построить индивидуальную траекторию обучения и стать AI Product Manager, AI Project Manager или Product Data Analyst. Вас ждут реальные проекты для компаний уровня Альфа-Банк, очные воркшопы и онлайн-лекции. Для выпускной работы вы можете выбрать проект для компан...",
     "url": "https://abit.itmo.ru/program/master/ai_product",
     "pdf_links": [
       {
-        "url": "https://abit.itmo.ru/program/master/ai_product/curriculum",
-        "text": "учебный план",
-        "filename": "ai_product_curriculum.pdf"
+        "url": "https://abit.itmo.ru/file_storage/file/exams/master/ai_product.pdf",
+        "filename": "document_ai_product.pdf",
+        "type": "document",
+        "text": "смотреть"
+      },
+      {
+        "url": "https://itmo.ru/file/pages/79/personal_data_policy.pdf",
+        "filename": "document_personal_data_policy.pdf",
+        "type": "document",
+        "text": "политика по обработке персональных данных"
+      },
+      {
+        "url": "https://itmo.ru/images/pages/79/Pravila_ispolzovanija_informacii.pdf",
+        "filename": "document_Pravila_ispolzovanija_informacii.pdf",
+        "type": "document",
+        "text": "правила использования информации в доменной зоне itmo.ru"
       }
     ],
-    "hash": "test_hash_ai_product"
+    "content_hash": "d1d3028e607032b00a5ca364ef85990a0258df0d2116fc7bdb6d5bd4106d07bb",
+    "last_updated": ""
   }
-}
+}

knowledge_base.py

@@ -25,6 +25,9 @@ class KnowledgeBase:
         except FileNotFoundError:
             print('Файлы данных не найдены, создаем тестовые данные...')
             self._create_test_data()
+        except Exception as e:
+            print(f'Ошибка загрузки данных: {e}, создаем тестовые данные...')
+            self._create_test_data()
     
     def _create_test_data(self):
         # Тестовые программы
@@ -191,7 +194,13 @@ class KnowledgeBase:
         message_lower = message.lower()
         return any(keyword in message_lower for keyword in itmo_keywords)
     
-    def get_courses_by_semester(self, semester: int) -> List[Dict]:
+    def get_courses_by_semester(self, semester) -> List[Dict]:
+        """Получает курсы для указанного семестра"""
+        try:
+            semester = int(semester)
+        except (ValueError, TypeError):
+            semester = 1
+        
         return [course for course in self.courses if course.get('semester') == semester]
     
     def get_course_by_id(self, course_id: str) -> Dict:

scraper/html_scraper.py

@@ -1,16 +1,16 @@
 import requests
-import re
-from bs4 import BeautifulSoup
-from typing import List, Dict
 import hashlib
 import json
 import os
+from typing import List, Dict
+from bs4 import BeautifulSoup
+import re
 
 class HTMLScraper:
     def __init__(self):
         self.session = requests.Session()
         self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
         })
         
         self.program_urls = {
@@ -23,9 +23,11 @@ class HTMLScraper:
         
         for program_id, url in self.program_urls.items():
             try:
-                print(f'Скрапинг программы {program_id}...')
+                print(f'Скрапинг программы: {program_id}')
                 program_data = self._scrape_program_page(url, program_id)
-                programs[program_id] = program_data
+                if program_data:
+                    programs[program_id] = program_data
+                    print(f'Успешно обработана программа: {program_data["title"]}')
             except Exception as e:
                 print(f'Ошибка при скрапинге {program_id}: {e}')
         
@@ -37,107 +39,221 @@ class HTMLScraper:
         
         soup = BeautifulSoup(response.content, 'html.parser')
         
+        # Извлечение заголовка
         title = self._extract_title(soup)
+        
+        # Извлечение описания
         description = self._extract_description(soup)
+        
+        # Поиск ссылок на PDF учебные планы
         pdf_links = self._extract_pdf_links(soup, url)
         
-        program_data = {
+        # Создание хэша контента для отслеживания изменений
+        content_hash = self._calculate_content_hash(response.content)
+        
+        return {
             'id': program_id,
             'title': title,
             'description': description,
             'url': url,
             'pdf_links': pdf_links,
-            'hash': self._calculate_hash(response.content)
+            'content_hash': content_hash,
+            'last_updated': response.headers.get('last-modified', '')
         }
-        
-        return program_data
     
     def _extract_title(self, soup: BeautifulSoup) -> str:
-        title_elem = soup.find('h1') or soup.find('title')
-        if title_elem:
-            return title_elem.get_text().strip()
-        return ''
+        # Поиск заголовка программы
+        title_selectors = [
+            'h1',
+            '.program-title',
+            '.title',
+            '[class*="title"]',
+            '[class*="header"]'
+        ]
+        
+        for selector in title_selectors:
+            title_elem = soup.select_one(selector)
+            if title_elem and title_elem.get_text().strip():
+                title = title_elem.get_text().strip()
+                if len(title) > 5:  # Минимальная длина заголовка
+                    return title
+        
+        # Fallback - поиск по ключевым словам
+        for elem in soup.find_all(['h1', 'h2', 'h3']):
+            text = elem.get_text().strip()
+            if any(keyword in text.lower() for keyword in ['искусственный интеллект', 'ai', 'продукт']):
+                return text
+        
+        return f'Программа {program_id.upper()}'
     
     def _extract_description(self, soup: BeautifulSoup) -> str:
+        # Поиск описания программы
         desc_selectors = [
             '.program-description',
             '.description',
-            '.program-info',
-            'p',
-            '.content'
+            '.about',
+            '[class*="description"]',
+            '[class*="about"]',
+            'p'
         ]
         
         for selector in desc_selectors:
-            elem = soup.select_one(selector)
-            if elem:
-                text = elem.get_text().strip()
-                if len(text) > 50:
-                    return text[:500]
+            desc_elem = soup.select_one(selector)
+            if desc_elem:
+                desc = desc_elem.get_text().strip()
+                if len(desc) > 50:  # Минимальная длина описания
+                    return desc[:500] + '...' if len(desc) > 500 else desc
         
-        return ''
+        # Fallback - поиск по ключевым словам
+        for elem in soup.find_all('p'):
+            text = elem.get_text().strip()
+            if any(keyword in text.lower() for keyword in ['магистратура', 'программа', 'обучение', 'подготовка']):
+                if len(text) > 30:
+                    return text[:500] + '...' if len(text) > 500 else text
+        
+        return 'Описание программы магистратуры ITMO'
     
     def _extract_pdf_links(self, soup: BeautifulSoup, base_url: str) -> List[Dict]:
         pdf_links = []
         
+        # Поиск всех ссылок на PDF
         for link in soup.find_all('a', href=True):
-            href = link.get('href', '')
+            href = link['href']
             text = link.get_text().strip().lower()
             
-            if self._is_pdf_link(href, text):
-                full_url = self._make_absolute_url(href, base_url)
+            # Проверка на PDF файлы
+            if href.endswith('.pdf') or 'pdf' in href:
+                # Определение типа документа по тексту ссылки
+                doc_type = self._determine_document_type(text)
+                
+                # Получение полного URL
+                if href.startswith('http'):
+                    full_url = href
+                else:
+                    full_url = self._make_absolute_url(href, base_url)
+                
+                # Генерация имени файла
+                filename = self._generate_filename(href, doc_type)
+                
                 pdf_links.append({
                     'url': full_url,
-                    'text': text,
-                    'filename': self._extract_filename(href)
+                    'filename': filename,
+                    'type': doc_type,
+                    'text': text
                 })
         
+        # Поиск по ключевым словам в тексте
+        if not pdf_links:
+            pdf_links = self._search_pdf_by_keywords(soup, base_url)
+        
         return pdf_links
     
-    def _is_pdf_link(self, href: str, text: str) -> bool:
-        pdf_indicators = [
-            'учебный план', 'учебный план', 'curriculum', 'plan',
-            'pdf', '.pdf', 'программа', 'program'
-        ]
+    def _determine_document_type(self, text: str) -> str:
+        text_lower = text.lower()
         
-        href_lower = href.lower()
-        return any(indicator in href_lower or indicator in text for indicator in pdf_indicators)
+        if any(word in text_lower for word in ['учебный план', 'curriculum', 'plan']):
+            return 'curriculum'
+        elif any(word in text_lower for word in ['программа', 'program']):
+            return 'program'
+        elif any(word in text_lower for word in ['описание', 'description']):
+            return 'description'
+        else:
+            return 'document'
     
     def _make_absolute_url(self, href: str, base_url: str) -> str:
-        if href.startswith('http'):
-            return href
+        if href.startswith('//'):
+            return 'https:' + href
         elif href.startswith('/'):
-            base = '/'.join(base_url.split('/')[:3])
-            return base + href
+            # Извлекаем домен из base_url
+            from urllib.parse import urlparse
+            parsed = urlparse(base_url)
+            return f"{parsed.scheme}://{parsed.netloc}{href}"
         else:
             return base_url.rstrip('/') + '/' + href.lstrip('/')
     
-    def _extract_filename(self, href: str) -> str:
+    def _generate_filename(self, href: str, doc_type: str) -> str:
+        # Извлекаем имя файла из URL
         filename = href.split('/')[-1]
         if not filename.endswith('.pdf'):
             filename += '.pdf'
-        return filename
+        
+        # Добавляем префикс типа документа
+        return f"{doc_type}_{filename}"
+    
+    def _search_pdf_by_keywords(self, soup: BeautifulSoup, base_url: str) -> List[Dict]:
+        pdf_links = []
+        
+        # Ключевые слова для поиска учебных планов
+        keywords = [
+            'учебный план',
+            'curriculum',
+            'программа обучения',
+            'образовательная программа'
+        ]
+        
+        # Поиск по тексту страницы
+        page_text = soup.get_text().lower()
+        
+        for keyword in keywords:
+            if keyword in page_text:
+                # Попытка найти ссылку рядом с ключевым словом
+                for elem in soup.find_all(['a', 'p', 'div']):
+                    text = elem.get_text().lower()
+                    if keyword in text:
+                        # Ищем ссылки в этом элементе или рядом
+                        links = elem.find_all('a', href=True)
+                        for link in links:
+                            href = link['href']
+                            if href.endswith('.pdf') or 'pdf' in href:
+                                full_url = self._make_absolute_url(href, base_url)
+                                pdf_links.append({
+                                    'url': full_url,
+                                    'filename': f"curriculum_{href.split('/')[-1]}",
+                                    'type': 'curriculum',
+                                    'text': link.get_text().strip()
+                                })
+        
+        return pdf_links
     
-    def _calculate_hash(self, content: bytes) -> str:
+    def _calculate_content_hash(self, content: bytes) -> str:
         return hashlib.sha256(content).hexdigest()
     
-    def save_programs(self, programs: Dict, output_path: str = 'data/processed/programs.json'):
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    def save_programs(self, programs: Dict):
+        os.makedirs('data/processed', exist_ok=True)
         
-        with open(output_path, 'w', encoding='utf-8') as f:
+        with open('data/processed/programs.json', 'w', encoding='utf-8') as f:
             json.dump(programs, f, ensure_ascii=False, indent=2)
         
-        print(f'Программы сохранены в {output_path}')
+        print(f'Программы сохранены: {len(programs)} программ')
+    
+    def check_updates(self, programs: Dict) -> Dict:
+        updates = {}
+        
+        for program_id, program in programs.items():
+            try:
+                response = self.session.get(program['url'], timeout=30)
+                current_hash = self._calculate_content_hash(response.content)
+                
+                if current_hash != program.get('content_hash'):
+                    updates[program_id] = {
+                        'old_hash': program.get('content_hash'),
+                        'new_hash': current_hash,
+                        'last_modified': response.headers.get('last-modified', '')
+                    }
+                    print(f'Обнаружены изменения в программе: {program_id}')
+            except Exception as e:
+                print(f'Ошибка проверки обновлений для {program_id}: {e}')
+        
+        return updates
 
 def main():
     scraper = HTMLScraper()
     programs = scraper.scrape_programs()
     scraper.save_programs(programs)
     
+    print(f'Обработано программ: {len(programs)}')
     for program_id, program in programs.items():
-        print(f'\n{program["title"]}:')
-        print(f'PDF ссылок найдено: {len(program["pdf_links"])}')
-        for link in program['pdf_links']:
-            print(f'  - {link["filename"]}: {link["url"]}')
+        print(f'{program_id}: {program["title"]} - {len(program["pdf_links"])} PDF')
 
 if __name__ == '__main__':
     main()

scraper/normalize.py

@@ -5,20 +5,31 @@ from typing import List, Dict
 class DataNormalizer:
     def __init__(self):
         self.tag_keywords = {
-            'ml': ['машинное обучение', 'machine learning', 'ml', 'алгоритм', 'модель'],
-            'dl': ['глубокое обучение', 'deep learning', 'нейронная сеть', 'cnn', 'rnn', 'transformer'],
-            'nlp': ['nlp', 'обработка естественного языка', 'natural language', 'текст', 'язык'],
-            'cv': ['компьютерное зрение', 'computer vision', 'cv', 'изображение', 'видео'],
-            'math': ['математика', 'математический', 'алгебра', 'геометрия', 'анализ'],
-            'stats': ['статистика', 'вероятность', 'статистический', 'probability'],
-            'product': ['продукт', 'product', 'разработка продукта', 'продуктовая'],
-            'business': ['бизнес', 'business', 'менеджмент', 'управление', 'экономика'],
-            'pm': ['project management', 'управление проектами', 'pm', 'проект'],
-            'systems': ['система', 'system', 'архитектура', 'инфраструктура'],
-            'data': ['данные', 'data', 'анализ данных', 'big data', 'база данных']
+            'ml': ['машинное обучение', 'machine learning', 'ml', 'алгоритм', 'модель', 'классификация', 'регрессия'],
+            'dl': ['глубокое обучение', 'deep learning', 'нейронная сеть', 'cnn', 'rnn', 'transformer', 'нейросеть'],
+            'nlp': ['nlp', 'обработка естественного языка', 'natural language', 'текст', 'язык', 'токенизация'],
+            'cv': ['компьютерное зрение', 'computer vision', 'cv', 'изображение', 'видео', 'детекция', 'сегментация'],
+            'math': ['математика', 'математический', 'алгебра', 'геометрия', 'анализ', 'линейная алгебра', 'статистика'],
+            'stats': ['статистика', 'вероятность', 'статистический', 'probability', 'теория вероятностей'],
+            'product': ['продукт', 'product', 'разработка продукта', 'продуктовая', 'аналитика'],
+            'business': ['бизнес', 'business', 'менеджмент', 'управление', 'экономика', 'маркетинг'],
+            'pm': ['project management', 'управление проектами', 'pm', 'проект', 'agile', 'scrum'],
+            'systems': ['система', 'system', 'архитектура', 'инфраструктура', 'разработка'],
+            'data': ['данные', 'data', 'анализ данных', 'big data', 'база данных', 'sql', 'nosql'],
+            'research': ['исследование', 'research', 'наука', 'научный', 'диссертация', 'магистерская'],
+            'python': ['python', 'питон', 'программирование'],
+            'java': ['java', 'джава', 'программирование'],
+            'sql': ['sql', 'база данных', 'database'],
+            'git': ['git', 'версионирование', 'контроль версий'],
+            'docker': ['docker', 'контейнеризация', 'контейнер'],
+            'aws': ['aws', 'amazon', 'облако', 'cloud'],
+            'tensorflow': ['tensorflow', 'tf', 'фреймворк'],
+            'pytorch': ['pytorch', 'torch', 'фреймворк'],
+            'scikit-learn': ['scikit-learn', 'sklearn', 'библиотека']
         }
     
     def normalize_courses(self, courses: List[Dict]) -> List[Dict]:
+        """Нормализует список курсов"""
         normalized_courses = []
         seen_hashes = set()
         
@@ -33,15 +44,22 @@ class DataNormalizer:
         return normalized_courses
     
     def _normalize_course(self, course: Dict) -> Dict:
+        """Нормализует отдельный курс"""
         if not course.get('name'):
             return None
         
         normalized = course.copy()
         
+        # Нормализация названия
         normalized['name'] = self._normalize_name(course['name'])
+        
+        # Генерация короткого описания
         normalized['short_desc'] = self._generate_short_desc(course)
+        
+        # Генерация тегов
         normalized['tags'] = self._generate_tags(course)
         
+        # Нормализация числовых полей
         normalized['semester'] = self._normalize_semester(course.get('semester', 1))
         normalized['credits'] = self._normalize_credits(course.get('credits', 0))
         normalized['hours'] = self._normalize_hours(course.get('hours', 0))
@@ -50,31 +68,51 @@ class DataNormalizer:
         return normalized
     
     def _normalize_name(self, name: str) -> str:
+        """Нормализует название курса"""
         if not name:
             return ''
         
         name = str(name).strip()
+        
+        # Удаляем лишние пробелы и символы
         name = re.sub(r'\s+', ' ', name)
-        name = name.replace('"', '').replace('"', '')
+        name = name.replace('"', '').replace('"', '').replace('«', '').replace('»', '')
+        
+        # Убираем лишние скобки и символы
+        name = re.sub(r'^\s*[\(\)\[\]\-\s]+', '', name)
+        name = re.sub(r'[\(\)\[\]\-\s]+\s*$', '', name)
         
         return name
     
-    def _generate_short_desc(self, course: dict) -> str:
+    def _generate_short_desc(self, course: Dict) -> str:
+        """Генерирует короткое описание курса"""
         name = course.get('name', '')
         desc = course.get('description', '')
         
+        # Если есть описание, используем его
         if desc:
             desc = str(desc).strip()
             if len(desc) > 220:
                 desc = desc[:220] + '...'
             return desc
         
+        # Если название длинное, используем его как описание
         if name and len(name) > 50:
             return name[:220]
         
-        return 'Курс из учебного плана программы'
+        # Генерируем базовое описание
+        program_id = course.get('program_id', '')
+        semester = course.get('semester', 1)
+        
+        if program_id == 'ai':
+            return f'Курс программы "Искусственный интеллект" ({semester} семестр)'
+        elif program_id == 'ai_product':
+            return f'Курс программы "AI Product Management" ({semester} семестр)'
+        else:
+            return f'Курс из учебного плана программы ({semester} семестр)'
     
     def _generate_tags(self, course: Dict) -> List[str]:
+        """Генерирует теги для курса"""
         text = f"{course.get('name', '')} {course.get('short_desc', '')}".lower()
         tags = []
         
@@ -82,9 +120,19 @@ class DataNormalizer:
             if any(keyword in text for keyword in keywords):
                 tags.append(tag)
         
-        return tags
+        # Добавляем теги на основе программы
+        program_id = course.get('program_id', '')
+        if program_id == 'ai':
+            if 'ml' not in tags:
+                tags.append('ml')
+        elif program_id == 'ai_product':
+            if 'product' not in tags:
+                tags.append('product')
+        
+        return list(set(tags))  # Убираем дубликаты
     
     def _normalize_semester(self, semester) -> int:
+        """Нормализует номер семестра"""
         try:
             semester = int(semester)
             if 1 <= semester <= 4:
@@ -95,6 +143,7 @@ class DataNormalizer:
         return 1
     
     def _normalize_credits(self, credits) -> int:
+        """Нормализует количество кредитов"""
         try:
             credits = int(credits)
             if credits >= 0:
@@ -105,6 +154,7 @@ class DataNormalizer:
         return 0
     
     def _normalize_hours(self, hours) -> int:
+        """Нормализует количество часов"""
         try:
             hours = int(hours)
             if hours >= 0:
@@ -115,23 +165,26 @@ class DataNormalizer:
         return 0
     
     def _normalize_type(self, course_type: str) -> str:
+        """Нормализует тип курса"""
         if not course_type:
             return 'required'
         
         type_lower = str(course_type).lower()
         
-        if any(word in type_lower for word in ['обязательная', 'required', 'обяз']):
+        if any(word in type_lower for word in ['обязательная', 'required', 'обяз', 'базовая']):
             return 'required'
-        elif any(word in type_lower for word in ['по выбору', 'elective', 'выбор']):
+        elif any(word in type_lower for word in ['по выбору', 'elective', 'выбор', 'электив', 'факультатив']):
             return 'elective'
         
         return 'required'
     
     def _calculate_course_hash(self, course: Dict) -> str:
+        """Вычисляет хэш курса для дедупликации"""
         text = f"{course.get('name', '')}{course.get('program_id', '')}{course.get('semester', '')}"
         return hashlib.md5(text.encode()).hexdigest()
     
     def merge_courses(self, courses_list: List[List[Dict]]) -> List[Dict]:
+        """Объединяет несколько списков курсов"""
         all_courses = []
         for courses in courses_list:
             all_courses.extend(courses)
@@ -139,6 +192,7 @@ class DataNormalizer:
         return self.normalize_courses(all_courses)
     
     def validate_course(self, course: Dict) -> bool:
+        """Проверяет валидность курса"""
         required_fields = ['name', 'program_id', 'semester']
         
         for field in required_fields:
@@ -151,6 +205,7 @@ class DataNormalizer:
         return True
     
     def get_statistics(self, courses: List[Dict]) -> Dict:
+        """Получает статистику по курсам"""
         stats = {
             'total_courses': len(courses),
             'by_program': {},
@@ -173,10 +228,94 @@ class DataNormalizer:
                 stats['by_tags'][tag] = stats['by_tags'].get(tag, 0) + 1
         
         return stats
+    
+    def enrich_courses(self, courses: List[Dict]) -> List[Dict]:
+        """Обогащает курсы дополнительной информацией"""
+        for course in courses:
+            # Добавляем сложность курса
+            course['difficulty'] = self._calculate_difficulty(course)
+            
+            # Добавляем рекомендуемый опыт
+            course['recommended_experience'] = self._calculate_recommended_experience(course)
+            
+            # Добавляем категорию
+            course['category'] = self._determine_category(course)
+        
+        return courses
+    
+    def _calculate_difficulty(self, course: Dict) -> str:
+        """Вычисляет сложность курса"""
+        name = course.get('name', '').lower()
+        credits = course.get('credits', 0)
+        semester = course.get('semester', 1)
+        
+        # По ключевым словам
+        if any(word in name for word in ['продвинутый', 'advanced', 'углубленный']):
+            return 'advanced'
+        elif any(word in name for word in ['базовый', 'basic', 'введение', 'вводный']):
+            return 'beginner'
+        
+        # По кредитам и семестру
+        if credits >= 6 or semester >= 3:
+            return 'intermediate'
+        elif credits <= 3 and semester <= 2:
+            return 'beginner'
+        else:
+            return 'intermediate'
+    
+    def _calculate_recommended_experience(self, course: Dict) -> Dict:
+        """Вычисляет рекомендуемый опыт для курса"""
+        difficulty = course.get('difficulty', 'intermediate')
+        tags = course.get('tags', [])
+        
+        experience = {
+            'programming': 1,
+            'math': 1,
+            'ml': 0
+        }
+        
+        if difficulty == 'advanced':
+            experience['programming'] = 4
+            experience['math'] = 3
+        elif difficulty == 'intermediate':
+            experience['programming'] = 2
+            experience['math'] = 2
+        else:  # beginner
+            experience['programming'] = 1
+            experience['math'] = 1
+        
+        # Корректировка по тегам
+        if 'ml' in tags or 'dl' in tags:
+            experience['ml'] = max(experience['ml'], 1)
+        if 'math' in tags or 'stats' in tags:
+            experience['math'] = max(experience['math'], 2)
+        if 'python' in tags or 'java' in tags:
+            experience['programming'] = max(experience['programming'], 2)
+        
+        return experience
+    
+    def _determine_category(self, course: Dict) -> str:
+        """Определяет категорию курса"""
+        tags = course.get('tags', [])
+        name = course.get('name', '').lower()
+        
+        if any(tag in tags for tag in ['ml', 'dl', 'nlp', 'cv']):
+            return 'ai_core'
+        elif any(tag in tags for tag in ['product', 'business', 'pm']):
+            return 'product_management'
+        elif any(tag in tags for tag in ['math', 'stats']):
+            return 'mathematics'
+        elif any(tag in tags for tag in ['systems', 'data']):
+            return 'systems_data'
+        elif 'research' in tags or 'диссертация' in name:
+            return 'research'
+        else:
+            return 'general'
 
 def main():
     normalizer = DataNormalizer()
     
+    # Тестовые курсы
     test_courses = [
         {
             'id': 'test_1',
@@ -197,10 +336,14 @@ def main():
     ]
     
     normalized = normalizer.normalize_courses(test_courses)
-    stats = normalizer.get_statistics(normalized)
+    enriched = normalizer.enrich_courses(normalized)
+    stats = normalizer.get_statistics(enriched)
     
     print(f'Нормализовано курсов: {len(normalized)}')
     print(f'Статистика: {stats}')
+    
+    for course in enriched:
+        print(f"- {course['name']}: {course['tags']} (сложность: {course['difficulty']})")
 
 if __name__ == '__main__':
     main()

scraper/pdf_parser.py

@@ -1,9 +1,10 @@
-import pdfplumber
 import requests
+import pdfplumber
+import os
 import re
 from typing import List, Dict
-import os
-from tqdm import tqdm
+import tempfile
+from urllib.parse import urlparse
 
 class PDFParser:
     def __init__(self):
@@ -13,232 +14,291 @@ class PDFParser:
         })
     
     def download_pdf(self, url: str, filename: str) -> str:
-        local_path = os.path.join('data/raw', filename)
-        
-        if os.path.exists(local_path):
-            print(f'PDF уже загружен: {filename}')
-            return local_path
-        
+        """Скачивает PDF файл и сохраняет локально"""
         try:
-            print(f'Загрузка PDF: {url}')
+            print(f'Скачивание PDF: {filename}')
             response = self.session.get(url, stream=True, timeout=60)
             response.raise_for_status()
             
+            # Создаем директорию если не существует
             os.makedirs('data/raw', exist_ok=True)
             
-            with open(local_path, 'wb') as f:
+            # Сохраняем файл
+            filepath = os.path.join('data/raw', filename)
+            with open(filepath, 'wb') as f:
                 for chunk in response.iter_content(chunk_size=8192):
                     f.write(chunk)
             
-            print(f'PDF сохранен: {local_path}')
-            return local_path
+            print(f'PDF сохранен: {filepath}')
+            return filepath
             
         except Exception as e:
-            print(f'Ошибка загрузки PDF {url}: {e}')
+            print(f'Ошибка скачивания PDF {url}: {e}')
             return None
     
-    def parse_pdf(self, pdf_path: str, program_id: str) -> List[Dict]:
+    def parse_pdf(self, filepath: str, program_id: str) -> List[Dict]:
+        """Парсит PDF и извлекает информацию о курсах"""
         courses = []
         
         try:
-            with pdfplumber.open(pdf_path) as pdf:
-                print(f'Парсинг PDF: {pdf_path}')
-                
-                for page_num, page in enumerate(tqdm(pdf.pages, desc='Страницы')):
-                    page_courses = self._parse_page(page, page_num + 1, program_id)
-                    courses.extend(page_courses)
-                
-                print(f'Найдено курсов: {len(courses)}')
+            print(f'Парсинг PDF: {filepath}')
+            
+            with pdfplumber.open(filepath) as pdf:
+                # Пробуем извлечь таблицы
+                table_courses = self._extract_from_tables(pdf, program_id)
+                if table_courses:
+                    courses.extend(table_courses)
+                    print(f'Извлечено из таблиц: {len(table_courses)} курсов')
                 
+                # Если таблиц нет или мало курсов, пробуем текстовый парсинг
+                if len(courses) < 5:
+                    text_courses = self._extract_from_text(pdf, program_id)
+                    courses.extend(text_courses)
+                    print(f'Извлечено из текста: {len(text_courses)} курсов')
+            
+            # Дедупликация курсов
+            courses = self._deduplicate_courses(courses)
+            
+            print(f'Всего извлечено курсов: {len(courses)}')
+            return courses
+            
         except Exception as e:
-            print(f'Ошибка парсинга PDF {pdf_path}: {e}')
-        
-        return courses
+            print(f'Ошибка парсинга PDF {filepath}: {e}')
+            return []
     
-    def _parse_page(self, page, page_num: int, program_id: str) -> List[Dict]:
+    def _extract_from_tables(self, pdf, program_id: str) -> List[Dict]:
+        """Извлекает курсы из таблиц PDF"""
         courses = []
+        current_semester = 1
         
-        try:
-            tables = page.extract_tables()
-            
-            for table in tables:
-                table_courses = self._parse_table(table, page_num, program_id)
-                courses.extend(table_courses)
-            
-            if not courses:
-                courses = self._parse_text_fallback(page, page_num, program_id)
+        for page_num, page in enumerate(pdf.pages):
+            try:
+                # Извлекаем таблицы
+                tables = page.extract_tables()
                 
-        except Exception as e:
-            print(f'Ошибка парсинга страницы {page_num}: {e}')
+                for table in tables:
+                    if not table or len(table) < 2:
+                        continue
+                    
+                    # Определяем семестр по заголовкам
+                    semester = self._detect_semester_from_table(table, current_semester)
+                    if semester:
+                        current_semester = semester
+                    
+                    # Парсим строки таблицы
+                    for row in table[1:]:  # Пропускаем заголовок
+                        if not row or len(row) < 2:
+                            continue
+                        
+                        course = self._parse_table_row(row, program_id, current_semester, page_num + 1)
+                        if course:
+                            courses.append(course)
+            
+            except Exception as e:
+                print(f'Ошибка обработки страницы {page_num + 1}: {e}')
+                continue
         
         return courses
     
-    def _parse_table(self, table: list, page_num: int, program_id: str) -> List[Dict]:
+    def _extract_from_text(self, pdf, program_id: str) -> List[Dict]:
+        """Извлекает курсы из текста PDF"""
         courses = []
+        current_semester = 1
         
-        if not table or len(table) < 2:
-            return courses
-        
-        headers = [str(cell).lower().strip() if cell else '' for cell in table[0]]
-        
-        for row_idx, row in enumerate(table[1:], 1):
-            if not row or len(row) < 3:
-                continue
+        for page_num, page in enumerate(pdf.pages):
+            try:
+                text = page.extract_text()
+                if not text:
+                    continue
+                
+                # Определяем семестр по тексту
+                semester = self._detect_semester_from_text(text, current_semester)
+                if semester:
+                    current_semester = semester
+                
+                # Ищем курсы в тексте
+                page_courses = self._parse_text_for_courses(text, program_id, current_semester, page_num + 1)
+                courses.extend(page_courses)
             
-            course = self._extract_course_from_row(row, headers, page_num, program_id)
-            if course:
-                courses.append(course)
+            except Exception as e:
+                print(f'Ошибка обработки текста страницы {page_num + 1}: {e}')
+                continue
         
         return courses
     
-    def _extract_course_from_row(self, row: list, headers: list, page_num: int, program_id: str) -> Dict:
-        try:
-            row = [str(cell).strip() if cell else '' for cell in row]
-            
-            name = self._extract_name(row, headers)
-            if not name or len(name) < 3:
-                return None
-            
-            semester = self._extract_semester(row, headers)
-            credits = self._extract_credits(row, headers)
-            hours = self._extract_hours(row, headers)
-            course_type = self._extract_type(row, headers)
-            
-            course = {
-                'id': f'{program_id}_{page_num}_{hash(name) % 10000}',
-                'program_id': program_id,
-                'semester': semester,
-                'name': name,
-                'credits': credits,
-                'hours': hours,
-                'type': course_type,
-                'source_pdf': os.path.basename(program_id),
-                'source_page': page_num
-            }
-            
-            return course
-            
-        except Exception as e:
-            print(f'Ошибка извлечения курса из строки: {e}')
-            return None
-    
-    def _extract_name(self, row: list, headers: list) -> str:
-        name_indicators = ['название', 'дисциплина', 'курс', 'предмет', 'name', 'course']
+    def _detect_semester_from_table(self, table: List[List], current_semester: int) -> int:
+        """Определяет семестр по заголовкам таблицы"""
+        if not table or not table[0]:
+            return current_semester
         
-        for i, header in enumerate(headers):
-            if any(indicator in header for indicator in name_indicators):
-                if i < len(row) and row[i]:
-                    return row[i]
+        header_text = ' '.join([str(cell) for cell in table[0] if cell]).lower()
         
-        if len(row) > 0 and row[0]:
-            return row[0]
+        # Поиск упоминаний семестров
+        for i in range(1, 5):
+            if f'{i} семестр' in header_text or f'{i} семестре' in header_text:
+                return i
         
-        return ''
-    
-    def _extract_semester(self, row: list, headers: list) -> int:
-        semester_indicators = ['семестр', 'semester', 'сем']
-        
-        for i, header in enumerate(headers):
-            if any(indicator in header for indicator in semester_indicators):
-                if i < len(row) and row[i]:
-                    try:
-                        return int(re.findall(r'\d+', row[i])[0])
-                    except:
-                        pass
-        
-        return 1
-    
-    def _extract_credits(self, row: list, headers: list) -> int:
-        credit_indicators = ['кредит', 'credit', 'зет', 'з.е.']
-        
-        for i, header in enumerate(headers):
-            if any(indicator in header for indicator in credit_indicators):
-                if i < len(row) and row[i]:
-                    try:
-                        return int(re.findall(r'\d+', row[i])[0])
-                    except:
-                        pass
-        
-        return 0
+        return current_semester
     
-    def _extract_hours(self, row: list, headers: list) -> int:
-        hour_indicators = ['час', 'hour', 'ауд']
-        
-        for i, header in enumerate(headers):
-            if any(indicator in header for indicator in hour_indicators):
-                if i < len(row) and row[i]:
-                    try:
-                        return int(re.findall(r'\d+', row[i])[0])
-                    except:
-                        pass
-        
-        return 0
+    def _detect_semester_from_text(self, text: str, current_semester: int) -> int:
+        """Определяет семестр по тексту"""
+        text_lower = text.lower()
+        
+        # Поиск упоминаний семестров
+        for i in range(1, 5):
+            if f'{i} семестр' in text_lower or f'{i} семестре' in text_lower:
+                return i
+        
+        return current_semester
     
-    def _extract_type(self, row: list, headers: list) -> str:
-        type_indicators = ['тип', 'type', 'вид']
-        
-        for i, header in enumerate(headers):
-            if any(indicator in header for indicator in type_indicators):
-                if i < len(row) and row[i]:
-                    text = row[i].lower()
-                    if any(word in text for word in ['обязательная', 'required', 'обяз']):
-                        return 'required'
-                    elif any(word in text for word in ['по выбору', 'elective', 'выбор']):
-                        return 'elective'
-        
-        return 'required'
+    def _parse_table_row(self, row: List, program_id: str, semester: int, page: int) -> Dict:
+        """Парсит строку таблицы и извлекает информацию о курсе"""
+        if not row or len(row) < 2:
+            return None
+        
+        # Очищаем ячейки от лишних символов
+        clean_row = [str(cell).strip() if cell else '' for cell in row]
+        
+        # Ищем название курса (обычно в первой или второй колонке)
+        course_name = ''
+        credits = 0
+        hours = 0
+        course_type = 'required'
+        
+        for i, cell in enumerate(clean_row):
+            if not cell or cell.lower() in ['название', 'дисциплина', 'курс', 'предмет']:
+                continue
+            
+            # Если это похоже на название курса
+            if len(cell) > 10 and not cell.isdigit():
+                course_name = cell
+                break
+        
+        # Ищем кредиты и часы
+        for cell in clean_row:
+            if cell.isdigit():
+                num = int(cell)
+                if 1 <= num <= 12:  # Кредиты обычно 1-12
+                    credits = num
+                elif 18 <= num <= 216:  # Часы обычно 18-216
+                    hours = num
+        
+        # Определяем тип курса
+        row_text = ' '.join(clean_row).lower()
+        if any(word in row_text for word in ['по выбору', 'электив', 'факультатив']):
+            course_type = 'elective'
+        
+        if not course_name or len(course_name) < 5:
+            return None
+        
+        return {
+            'id': f'{program_id}_{semester}_{len(course_name)}',
+            'program_id': program_id,
+            'semester': semester,
+            'name': course_name,
+            'credits': credits,
+            'hours': hours,
+            'type': course_type,
+            'source_pdf': os.path.basename(filepath) if 'filepath' in locals() else '',
+            'source_page': page
+        }
     
-    def _parse_text_fallback(self, page, page_num: int, program_id: str) -> List[Dict]:
+    def _parse_text_for_courses(self, text: str, program_id: str, semester: int, page: int) -> List[Dict]:
+        """Парсит текст и ищет курсы"""
         courses = []
         
-        try:
-            text = page.extract_text()
-            if not text:
-                return courses
-            
-            lines = text.split('\n')
-            current_semester = 1
+        # Разбиваем текст на строки
+        lines = text.split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            if not line or len(line) < 10:
+                continue
             
-            for line in lines:
-                line = line.strip()
-                if not line:
+            # Ищем паттерны курсов
+            course = self._extract_course_from_line(line, program_id, semester, page)
+            if course:
+                courses.append(course)
+        
+        return courses
+    
+    def _extract_course_from_line(self, line: str, program_id: str, semester: int, page: int) -> Dict:
+        """Извлекает информацию о курсе из строки текста"""
+        # Паттерны для поиска курсов
+        patterns = [
+            r'([А-Я][А-Яа-я\s\-\(\)]+?)\s+(\d+)\s+(\d+)',  # Название + кредиты + часы
+            r'([А-Я][А-Яа-я\s\-\(\)]+?)\s+(\d+)\s*кр',     # Название + кредиты
+            r'([А-Я][А-Яа-я\s\-\(\)]+?)\s+(\d+)\s*ч',      # Название + часы
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, line)
+            if match:
+                course_name = match.group(1).strip()
+                if len(course_name) < 5:
                     continue
                 
-                if 'семестр' in line.lower():
-                    semester_match = re.findall(r'\d+', line)
-                    if semester_match:
-                        current_semester = int(semester_match[0])
-                    continue
+                # Извлекаем числа
+                numbers = [int(match.group(i)) for i in range(2, len(match.groups()) + 1)]
                 
-                if len(line) > 10 and not line.isdigit():
-                    course = {
-                        'id': f'{program_id}_{page_num}_{hash(line) % 10000}',
-                        'program_id': program_id,
-                        'semester': current_semester,
-                        'name': line,
-                        'credits': 0,
-                        'hours': 0,
-                        'type': 'required',
-                        'source_pdf': os.path.basename(program_id),
-                        'source_page': page_num
-                    }
-                    courses.append(course)
-                    
-        except Exception as e:
-            print(f'Ошибка fallback парсинга страницы {page_num}: {e}')
+                credits = 0
+                hours = 0
+                
+                if len(numbers) >= 2:
+                    credits, hours = numbers[0], numbers[1]
+                elif len(numbers) == 1:
+                    if numbers[0] <= 12:
+                        credits = numbers[0]
+                    else:
+                        hours = numbers[0]
+                
+                # Определяем тип курса
+                course_type = 'required'
+                if any(word in line.lower() for word in ['по выбору', 'электив', 'факультатив']):
+                    course_type = 'elective'
+                
+                return {
+                    'id': f'{program_id}_{semester}_{len(course_name)}',
+                    'program_id': program_id,
+                    'semester': semester,
+                    'name': course_name,
+                    'credits': credits,
+                    'hours': hours,
+                    'type': course_type,
+                    'source_page': page
+                }
         
-        return courses
+        return None
+    
+    def _deduplicate_courses(self, courses: List[Dict]) -> List[Dict]:
+        """Удаляет дубликаты курсов"""
+        seen = set()
+        unique_courses = []
+        
+        for course in courses:
+            # Создаем ключ для дедупликации
+            key = f"{course['name']}_{course['semester']}_{course['program_id']}"
+            
+            if key not in seen:
+                seen.add(key)
+                unique_courses.append(course)
+        
+        return unique_courses
 
 def main():
     parser = PDFParser()
     
-    test_url = 'https://example.com/test.pdf'
-    test_filename = 'test.pdf'
+    # Тестовый URL (замените на реальный)
+    test_url = "https://example.com/test.pdf"
+    filename = "test_curriculum.pdf"
     
-    local_path = parser.download_pdf(test_url, test_filename)
-    if local_path:
-        courses = parser.parse_pdf(local_path, 'test_program')
-        print(f'Найдено курсов: {len(courses)}')
+    # Скачивание и парсинг
+    filepath = parser.download_pdf(test_url, filename)
+    if filepath:
+        courses = parser.parse_pdf(filepath, 'test_program')
+        print(f'Извлечено курсов: {len(courses)}')
+        for course in courses[:5]:
+            print(f"- {course['name']} ({course['semester']} семестр, {course['credits']} кредитов)")
 
 if __name__ == '__main__':
     main()

test_chatbot.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from chatbot import ITMOChatbot
+from knowledge_base import KnowledgeBase
+
+def test_chatbot():
+    print("🧪 Тестирование чат-бота...")
+    
+    # Инициализация
+    try:
+        chatbot = ITMOChatbot()
+        print("✅ Чат-бот инициализирован")
+    except Exception as e:
+        print(f"❌ Ошибка инициализации: {e}")
+        return
+    
+    # Проверка базы знаний
+    kb = KnowledgeBase()
+    print(f"📊 Курсов в базе: {len(kb.courses)}")
+    
+    # Тест поиска курсов по семестрам
+    for semester in [1, 2, 3, 4]:
+        courses = kb.get_courses_by_semester(semester)
+        print(f"📚 Семестр {semester}: {len(courses)} курсов")
+        if courses:
+            print(f"   Пример: {courses[0]['name']}")
+    
+    # Тест чата
+    print("\n💬 Тест чата:")
+    test_messages = [
+        "Какие дисциплины по NLP в 1 семестре программы ИИ?",
+        "Расскажи о программе AI Product",
+        "Сколько кредитов за курс машинного обучения?"
+    ]
+    
+    history = []
+    for message in test_messages:
+        print(f"\n👤 Вопрос: {message}")
+        try:
+            response, score = chatbot.chat(message, history)
+            print(f"🤖 Ответ: {response[:100]}...")
+            print(f"📊 Релевантность: {score:.2f}")
+            history.append([message, response])
+        except Exception as e:
+            print(f"❌ Ошибка: {e}")
+    
+    # Тест рекомендаций
+    print("\n🎯 Тест рекомендаций:")
+    test_profiles = [
+        {
+            'programming_experience': 4,
+            'math_level': 3,
+            'interests': ['ml', 'dl', 'python'],
+            'semester': 1
+        },
+        {
+            'programming_experience': 2,
+            'math_level': 2,
+            'interests': ['product', 'business'],
+            'semester': 2
+        }
+    ]
+    
+    for i, profile in enumerate(test_profiles, 1):
+        print(f"\n👤 Профиль {i}: {profile}")
+        try:
+            recommendations = chatbot.recommend_courses(profile)
+            print(f"🎯 Рекомендации: {recommendations[:200]}...")
+        except Exception as e:
+            print(f"❌ Ошибка: {e}")
+    
+    print("\n✅ Тестирование завершено!")
+
+if __name__ == '__main__':
+    test_chatbot()

update_data.py

@@ -2,36 +2,90 @@ import json
 import os
 import sys
 from typing import List, Dict
+from scraper.html_scraper import HTMLScraper
+from scraper.pdf_parser import PDFParser
+from scraper.normalize import DataNormalizer
 from knowledge_base import KnowledgeBase
 from retriever import Retriever
 
 def update_data_async():
     try:
-        print('Начинаем обновление данных...')
+        print('Начинаем обновление данных с сайтов ITMO...')
         
-        # Проверяем, есть ли уже данные
-        if check_data_exists():
-            print('Данные уже существуют, пропускаем обновление')
-            return
-        
-        # Создаем тестовые данные для быстрого старта
-        print('Создание тестовых данных...')
+        # 1. Скрапинг страниц программ
+        scraper = HTMLScraper()
+        programs = scraper.scrape_programs()
+        scraper.save_programs(programs)
         
-        # Инициализация базы знаний (создаст тестовые данные)
-        knowledge_base = KnowledgeBase()
+        if not programs:
+            print('Не удалось получить данные программ, используем тестовые данные')
+            knowledge_base = KnowledgeBase()
+            retriever = Retriever()
+            retriever.build_or_load_index(knowledge_base.courses)
+            return
         
-        print('Создание индекса...')
-        retriever = Retriever()
-        retriever.build_or_load_index(knowledge_base.courses)
+        # 2. Скачивание и парсинг PDF
+        pdf_parser = PDFParser()
+        all_courses = []
         
-        stats = knowledge_base.get_statistics()
-        print(f'Статистика: {stats}')
+        for program_id, program in programs.items():
+            print(f'\nОбработка программы: {program["title"]}')
+            
+            if not program.get('pdf_links'):
+                print(f'PDF ссылки не найдены для программы {program_id}')
+                continue
+            
+            for pdf_link in program['pdf_links']:
+                try:
+                    filename = pdf_link['filename']
+                    url = pdf_link['url']
+                    
+                    print(f'Скачивание PDF: {filename}')
+                    local_path = pdf_parser.download_pdf(url, filename)
+                    
+                    if local_path:
+                        print(f'Парсинг PDF: {filename}')
+                        courses = pdf_parser.parse_pdf(local_path, program_id)
+                        all_courses.extend(courses)
+                        print(f'Извлечено курсов из {filename}: {len(courses)}')
+                    else:
+                        print(f'Не удалось скачать PDF: {filename}')
+                    
+                except Exception as e:
+                    print(f'Ошибка обработки PDF {pdf_link["filename"]}: {e}')
         
-        print('Обновление данных завершено успешно!')
+        # 3. Нормализация данных
+        if all_courses:
+            print(f'\nНормализация {len(all_courses)} курсов...')
+            normalizer = DataNormalizer()
+            normalized_courses = normalizer.normalize_courses(all_courses)
+            enriched_courses = normalizer.enrich_courses(normalized_courses)
+            
+            # Сохранение курсов
+            save_courses(enriched_courses)
+            
+            # 4. Создание индекса
+            print('Создание индекса...')
+            retriever = Retriever()
+            retriever.build_or_load_index(enriched_courses)
+            
+            # Статистика
+            stats = normalizer.get_statistics(enriched_courses)
+            print(f'Статистика: {stats}')
+            
+            print('Обновление данных завершено успешно!')
+        else:
+            print('Не удалось извлечь курсы из PDF, используем тестовые данные')
+            knowledge_base = KnowledgeBase()
+            retriever = Retriever()
+            retriever.build_or_load_index(knowledge_base.courses)
             
     except Exception as e:
         print(f'Ошибка обновления данных: {e}')
-        raise
+        print('Используем тестовые данные...')
+        knowledge_base = KnowledgeBase()
+        retriever = Retriever()
+        retriever.build_or_load_index(knowledge_base.courses)
 
 def save_courses(courses: List[Dict], output_path: str = 'data/processed/courses.json'):
     os.makedirs(os.path.dirname(output_path), exist_ok=True)
@@ -66,26 +120,57 @@ def load_existing_data() -> tuple[Dict, List[Dict]]:
     
     return programs, courses
 
+def check_for_updates() -> bool:
+    """Проверяет наличие обновлений на сайтах ITMO"""
+    try:
+        scraper = HTMLScraper()
+        programs, _ = load_existing_data()
+        
+        if not programs:
+            return True  # Нет данных, нужно обновление
+        
+        updates = scraper.check_updates(programs)
+        return len(updates) > 0
+        
+    except Exception as e:
+        print(f'Ошибка проверки обновлений: {e}')
+        return False
+
 def initialize_data():
     if check_data_exists():
-        print('Данные уже существуют, загружаем...')
-        programs, courses = load_existing_data()
+        print('Данные уже существуют, проверяем обновления...')
         
-        if courses:
-            retriever = Retriever()
-            retriever.build_or_load_index(courses)
-            print(f'Загружено {len(courses)} курсов')
-        else:
-            print('Курсы не найдены, запускаем обновление...')
+        if check_for_updates():
+            print('Обнаружены обновления, запускаем обновление данных...')
             update_data_async()
+        else:
+            print('Обновлений не найдено, загружаем существующие данные...')
+            programs, courses = load_existing_data()
+            
+            if courses:
+                retriever = Retriever()
+                retriever.build_or_load_index(courses)
+                print(f'Загружено {len(courses)} курсов')
+            else:
+                print('Курсы не найдены, запускаем обновление...')
+                update_data_async()
     else:
         print('Данные не найдены, запускаем первичное обновление...')
         update_data_async()
 
 def main():
-    if len(sys.argv) > 1 and sys.argv[1] == '--force':
-        print('Принудительное обновление данных...')
-        update_data_async()
+    if len(sys.argv) > 1:
+        if sys.argv[1] == '--force':
+            print('Принудительное обновление данных...')
+            update_data_async()
+        elif sys.argv[1] == '--check':
+            print('Проверка обновлений...')
+            if check_for_updates():
+                print('Обнаружены обновления')
+            else:
+                print('Обновлений не найдено')
+        else:
+            print('Использование: python update_data.py [--force|--check]')
     else:
         initialize_data()