Update app.py

app.py

@@ -15,7 +15,8 @@ logger = logging.getLogger(__name__)
 
 def clean_text(text):
     """Очищает текст от лишних пробелов и переносов строк"""
-    return ' '.join(text.split())
+    text = re.sub(r'\s+', ' ', text)
+    return text.strip()
 
 def count_emojis(text):
     """Подсчитывает количество эмодзи в тексте"""
@@ -34,19 +35,28 @@ def analyze_sentiment(text):
     """Расширенный анализ тональности по эмодзи и ключевым словам"""
     positive_indicators = ['🔥', '❤️', '👍', '😊', '💪', '👏', '🎉', '♥️', '😍', '🙏',
                          'круто', 'супер', 'класс', 'огонь', 'пушка', 'отлично', 'здорово',
-                         'прекрасно', 'молодец', 'красота', 'спасибо', 'топ', 'лучший']
+                         'прекрасно', 'молодец', 'красота', 'спасибо', 'топ', 'лучший',
+                         'amazing', 'wonderful', 'great', 'perfect', 'love', 'beautiful']
+    
     negative_indicators = ['👎', '😢', '😞', '😠', '😡', '💔', '😕', '😑', 
                          'плохо', 'ужас', 'отстой', 'фу', 'жесть', 'ужасно',
-                         'разочарован', 'печаль', 'грустно']
+                         'разочарован', 'печаль', 'грустно', 'bad', 'worst',
+                         'terrible', 'awful', 'sad', 'disappointed']
     
     text_lower = text.lower()
+    
+    # Подсчет индикаторов настроения
     positive_count = sum(1 for ind in positive_indicators if ind in text_lower)
     negative_count = sum(1 for ind in negative_indicators if ind in text_lower)
     
+    # Учет восклицательных знаков
     exclamation_count = text.count('!')
-    positive_count += exclamation_count * 0.5 if positive_count > negative_count else 0
-    negative_count += exclamation_count * 0.5 if negative_count > positive_count else 0
+    if positive_count > negative_count:
+        positive_count += exclamation_count * 0.5
+    elif negative_count > positive_count:
+        negative_count += exclamation_count * 0.5
     
+    # Определение итогового настроения
     if positive_count > negative_count:
         return 'positive'
     elif negative_count > positive_count:
@@ -54,62 +64,122 @@ def analyze_sentiment(text):
     return 'neutral'
 
 def extract_comment_data(comment_text):
-    """Извлекает данные из отдельного комментария"""
+    """Извлекает данные из отдельного комментария с поддержкой различных форматов"""
     try:
-        if 'Скрыто алгоритмами Instagram' in comment_text:
-            username_match = re.search(r"Фото профиля ([^\n]+)", comment_text)
-            if username_match:
-                return username_match.group(1).strip(), "", 0, 0
-            
-        username_match = re.search(r"Фото профиля ([^\n]+)", comment_text)
-        if not username_match:
-            return None, None, 0, 0
-        
-        username = username_match.group(1).strip()
-        
-        comment_pattern = fr"{re.escape(username)}\n(.*?)(?:\d+ нед\.)"
-        comment_match = re.search(comment_pattern, comment_text, re.DOTALL)
-        if comment_match:
-            comment = clean_text(comment_match.group(1))
-            comment = re.sub(fr'^{re.escape(username)}\s*', '', comment)
-            comment = re.sub(r'^@[\w\.]+ ', '', comment)
-        else:
-            comment = ""
+        # Паттерны для извлечения данных
+        username_patterns = [
+            r"Фото профиля ([^\n]+)",
+            r"^([^\s]+)\s+",
+            r"@([^\s]+)\s+",
+        ]
         
-        week_match = re.search(r'(\d+) нед\.', comment_text)
-        weeks = int(week_match.group(1)) if week_match else 0
+        time_patterns = [
+            r"(\d+)\s*(?:ч|нед)\.",
+            r"(\d+)\s*(?:h|w)",
+            r"(\d+)\s*(?:час|hour|week)",
+        ]
         
-        likes = 0
         likes_patterns = [
             r"(\d+) отметк[аи] \"Нравится\"",
             r"Нравится: (\d+)",
+            r"(\d+) отметка \"Нравится\"",
+            r"\"Нравится\": (\d+)",
+            r"likes?: (\d+)",
+        ]
+
+        # Поиск имени пользователя
+        username = None
+        for pattern in username_patterns:
+            username_match = re.search(pattern, comment_text)
+            if username_match:
+                username = username_match.group(1).strip()
+                break
+                
+        if not username:
+            return None, None, 0, 0
+
+        # Извлечение комментария
+        comment = comment_text
+        
+        # Удаление метаданных
+        metadata_patterns = [
+            r"Фото профиля [^\n]+\n",
+            r"\d+\s*(?:ч|нед|h|w|час|hour|week)\.",
+            r"Нравится:?\s*\d+",
+            r"\d+ отметк[аи] \"Нравится\"",
+            r"Ответить",
+            r"Показать перевод",
+            r"Скрыть все ответы",
+            r"Смотреть все ответы \(\d+\)",
+            username
         ]
         
+        for pattern in metadata_patterns:
+            comment = re.sub(pattern, '', comment)
+        
+        comment = clean_text(comment)
+
+        # Определение времени публикации
+        weeks = 0
+        for pattern in time_patterns:
+            time_match = re.search(pattern, comment_text)
+            if time_match:
+                time_value = int(time_match.group(1))
+                if any(unit in comment_text.lower() for unit in ['нед', 'w', 'week']):
+                    weeks = time_value
+                else:
+                    weeks = time_value / (24 * 7)  # конвертация часов в недели
+                break
+
+        # Подсчет лайков
+        likes = 0
         for pattern in likes_patterns:
             likes_match = re.search(pattern, comment_text)
             if likes_match:
                 likes = int(likes_match.group(1))
                 break
-        
+
         return username, comment.strip(), likes, weeks
+        
     except Exception as e:
         logger.error(f"Error extracting comment data: {e}")
         return None, None, 0, 0
 
-def analyze_post(content_type, link_to_post, post_likes, post_date, description, comment_count, all_comments):
+def analyze_post(content_type: str, link_to_post: str, post_likes: int, post_date: str, 
+                description: str, comment_count: int, all_comments: str) -> Tuple[str, str, str, str, str]:
+    """
+    Анализирует пост Instagram и его комментарии
+    
+    Args:
+        content_type: Тип контента (фото/видео)
+        link_to_post: Ссылка на пост
+        post_likes: Количество лайков поста
+        post_date: Дата публикации
+        description: Описание поста
+        comment_count: Ожидаемое количество комментариев
+        all_comments: Текст всех комментариев
+        
+    Returns:
+        Tuple[str, str, str, str, str]: Кортеж с результатами анализа
+    """
     try:
-        # Улучшенное разделение комментариев
-        comments_blocks = re.split(r'(?=Фото профиля|Скрыто алгоритмами Instagram)', all_comments)
-        comments_blocks = [block for block in comments_blocks if block.strip()]
+        # Разделение на блоки комментариев
+        comment_patterns = [
+            r"(?=Фото профиля)",
+            r"(?=\n\s*[a-zA-Z0-9._]+\s+[^\n]+\n)",
+            r"(?=^[a-zA-Z0-9._]+\s+[^\n]+\n)",
+            r"(?=@[a-zA-Z0-9._]+\s+[^\n]+\n)"
+        ]
         
-        # Подсчет скрытых комментариев
-        hidden_comments = len(re.findall(r'Скрыто алгоритмами Instagram', all_comments))
+        split_pattern = '|'.join(comment_patterns)
+        comments_blocks = re.split(split_pattern, all_comments)
+        comments_blocks = [block.strip() for block in comments_blocks if block and block.strip()]
         
+        # Инициализация переменных для анализа
         usernames = []
         comments = []
         likes = []
         weeks = []
-        
         total_emojis = 0
         mentions = []
         sentiments = []
@@ -124,12 +194,13 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                 continue
                 
             username, comment, like_count, week_number = extract_comment_data(block)
-            if username and (comment is not None):
+            if username and comment:
                 usernames.append(username)
                 comments.append(comment)
                 likes.append(str(like_count))
                 weeks.append(week_number)
                 
+                # Сбор статистики
                 total_emojis += count_emojis(comment)
                 mentions.extend(extract_mentions(comment))
                 sentiment = analyze_sentiment(comment)
@@ -140,6 +211,7 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                 words_per_comment.append(len(words))
                 all_words.extend(words)
                 
+                # Обновление статистики пользователя
                 if username not in user_engagement:
                     user_engagement[username] = {
                         'comments': 0,
@@ -147,8 +219,9 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                         'emoji_usage': 0,
                         'avg_length': 0,
                         'sentiments': [],
-                        'weeks': []  # Добавлено для анализа временной активности
+                        'weeks': []
                     }
+                    
                 user_stats = user_engagement[username]
                 user_stats['comments'] += 1
                 user_stats['total_likes'] += like_count
@@ -157,10 +230,10 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                 user_stats['sentiments'].append(sentiment)
                 user_stats['weeks'].append(week_number)
         
-        # Проверка количества комментариев
+        # Расчет статистики
         total_comments = len(comments)
-        if total_comments != comment_count:
-            logger.warning(f"Found {total_comments} comments, but expected {comment_count}")
+        if total_comments == 0:
+            return "No comments found", "", "", "", "0"
             
         # Обновление статистики пользователей
         for username in user_engagement:
@@ -170,47 +243,49 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
             stats['sentiment_ratio'] = sum(1 for s in stats['sentiments'] if s == 'positive') / len(stats['sentiments'])
             stats['activity_period'] = max(stats['weeks']) - min(stats['weeks']) if stats['weeks'] else 0
         
-        # Расчет базовой статистики
+        # Базовая статистика
         avg_comment_length = sum(comment_lengths) / total_comments
         sentiment_distribution = Counter(sentiments)
         most_active_users = Counter(usernames).most_common(5)
         most_mentioned = Counter(mentions).most_common(5)
         avg_likes = sum(map(int, likes)) / len(likes) if likes else 0
-        earliest_week = max(weeks) if weeks else 0
-        latest_week = min(weeks) if weeks else 0
-        
-        # Расширенная статистика
-        median_comment_length = statistics.median(comment_lengths)
-        avg_words_per_comment = sum(words_per_comment) / total_comments
-        common_words = Counter(all_words).most_common(10)
         
-        # Экспериментальная аналитика
-        engagement_periods = {
-            'early': [],
-            'middle': [],
-            'late': []
-        }
-        week_range = max(weeks) - min(weeks) if weeks else 0
-        period_length = week_range / 3 if week_range > 0 else 1
-        
-        for i, week in enumerate(weeks):
-            if week >= max(weeks) - period_length:
-                engagement_periods['early'].append(i)
-            elif week >= max(weeks) - 2 * period_length:
-                engagement_periods['middle'].append(i)
-            else:
-                engagement_periods['late'].append(i)
-        
-        period_stats = {
-            period: {
-                'comments': len(indices),
-                'avg_likes': sum(int(likes[i]) for i in indices) / len(indices) if indices else 0,
-                'sentiment_ratio': sum(1 for i in indices if sentiments[i] == 'positive') / len(indices) if indices else 0
+        # Временной анализ
+        if weeks:
+            earliest_week = max(weeks)
+            latest_week = min(weeks)
+            week_range = earliest_week - latest_week
+            
+            # Разделение на периоды
+            period_length = week_range / 3 if week_range > 0 else 1
+            engagement_periods = {
+                'early': [],
+                'middle': [],
+                'late': []
             }
-            for period, indices in engagement_periods.items()
-        }
+            
+            for i, week in enumerate(weeks):
+                if week >= earliest_week - period_length:
+                    engagement_periods['early'].append(i)
+                elif week >= earliest_week - 2 * period_length:
+                    engagement_periods['middle'].append(i)
+                else:
+                    engagement_periods['late'].append(i)
+            
+            period_stats = {
+                period: {
+                    'comments': len(indices),
+                    'avg_likes': sum(int(likes[i]) for i in indices) / len(indices) if indices else 0,
+                    'sentiment_ratio': sum(1 for i in indices if sentiments[i] == 'positive') / len(indices) if indices else 0
+                }
+                for period, indices in engagement_periods.items()
+            }
+        else:
+            period_stats = {}
+            earliest_week = 0
+            latest_week = 0
         
-        # Подготовка данных для CSV
+        # Подготовка CSV
         csv_data = {
             'metadata': {
                 'content_type': content_type,
@@ -218,27 +293,22 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                 'post_likes': post_likes,
                 'post_date': post_date,
                 'total_comments': total_comments,
-                'expected_comments': comment_count,
-                'hidden_comments': hidden_comments
+                'expected_comments': comment_count
             },
             'basic_stats': {
-                'avg_comment_length': avg_comment_length,
-                'median_comment_length': median_comment_length,
-                'avg_words': avg_words_per_comment,
+                'avg_comment_length': round(avg_comment_length, 2),
+                'median_comment_length': statistics.median(comment_lengths),
+                'avg_words': round(sum(words_per_comment) / total_comments, 2),
                 'total_emojis': total_emojis,
-                'avg_likes': avg_likes
-            },
-            'sentiment_stats': {
-                'positive': sentiment_distribution['positive'],
-                'neutral': sentiment_distribution['neutral'],
-                'negative': sentiment_distribution['negative']
+                'avg_likes': round(avg_likes, 2)
             },
+            'sentiment_stats': dict(Counter(sentiments)),
             'period_analysis': period_stats,
             'top_users': dict(most_active_users),
             'top_mentioned': dict(most_mentioned)
         }
         
-        # Создаем CSV строку
+        # Создание CSV строки
         output = StringIO()
         writer = csv.writer(output)
         for section, data in csv_data.items():
@@ -248,7 +318,7 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
             writer.writerow([])
         csv_output = output.getvalue()
         
-        # Формируем текстовый отчет
+        # Формирование отчета
         analytics_summary = (
             f"CSV DATA:\n{csv_output}\n\n"
             f"ДЕТАЛЬНЫЙ АНАЛИЗ:\n"
@@ -256,10 +326,18 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
             f"Ссылка: {link_to_post}\n\n"
             f"СТАТИСТИКА:\n"
             f"- Всего комментариев: {total_comments} (ожидалось: {comment_count})\n"
-            f"- Скрытых комментариев: {hidden_comments}\n"
-            f"- Всего лайков: {sum(map(int, likes))}\n"
-            f"- Среднее лайков: {avg_likes:.1f}\n"
-            f"- Период: {earliest_week}-{latest_week} недель\n\n"
+            f"- Всего лайков на комментариях: {sum(map(int, likes))}\n"
+            f"- Среднее лайков на комментарий: {avg_likes:.1f}\n"
+            f"- Период активности: {earliest_week}-{latest_week} недель\n\n"
+            f"АНАЛИЗ КОНТЕНТА:\n"
+            f"- Средняя длина комментария: {avg_comment_length:.1f} символов\n"
+            f"- Медиана длины: {statistics.median(comment_lengths)} символов\n"
+            f"- Среднее количество слов: {sum(words_per_comment) / total_comments:.1f}\n"
+            f"- Всего эмодзи: {total_emojis}\n"
+            f"- Тональность:\n"
+            f"  * Позитивных: {sentiment_distribution['positive']}\n"
+            f"  * Нейтральных: {sentiment_distribution['neutral']}\n"
+            f"  * Негативных: {sentiment_distribution['negative']}\n\n"
             f"АНАЛИЗ КОНТЕНТА:\n"
             f"- Средняя длина: {avg_comment_length:.1f} символов\n"
             f"- Медиана длины: {median_comment_length} символов\n"