Update app.py

app.py

@@ -1,108 +1,87 @@
-import gradio as gr
+# analyzers.py
 import re
-from collections import Counter
-from datetime import datetime
 import emoji
-import logging
-from typing import Tuple, List, Optional
 import statistics
-import csv
+from collections import Counter
+from typing import Dict, List, Tuple, Optional
+import logging
 from io import StringIO
+import csv
 
-# Настройка логирования
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-def clean_text(text):
-    """Очищает текст от лишних пробелов и переносов строк"""
-    text = re.sub(r'\s+', ' ', text)
-    return text.strip()
-
-def count_emojis(text):
-    """Подсчитывает количество эмодзи в тексте"""
-    return len([c for c in text if c in emoji.EMOJI_DATA])
-
-def extract_mentions(text):
-    """Извлекает упоминания пользователей из текста"""
-    return re.findall(r'@[\w\.]+', text)
-
-def get_comment_words(text):
-    """Получает список слов из комментария для анализа"""
-    words = re.findall(r'\w+', text.lower())
-    return [w for w in words if len(w) > 2]
-
-def analyze_sentiment(text):
-    """Расширенный анализ тональности по эмодзи и ключевым словам"""
-    positive_indicators = ['🔥', '❤️', '👍', '😊', '💪', '👏', '🎉', '♥️', '😍', '🙏',
-                         'круто', 'супер', 'класс', 'огонь', 'пушка', 'отлично', 'здорово',
-                         'прекрасно', 'молодец', 'красота', 'спасибо', 'топ', 'лучший',
-                         'amazing', 'wonderful', 'great', 'perfect', 'love', 'beautiful']
+class TextAnalyzer:
+    """Класс для базового анализа текста"""
+    @staticmethod
+    def clean_text(text: str) -> str:
+        return re.sub(r'\s+', ' ', text).strip()
     
-    negative_indicators = ['👎', '😢', '😞', '😠', '😡', '💔', '😕', '😑', 
-                         'плохо', 'ужас', 'отстой', 'фу', 'жесть', 'ужасно',
-                         'разочарован', 'печаль', 'грустно', 'bad', 'worst',
-                         'terrible', 'awful', 'sad', 'disappointed']
+    @staticmethod
+    def count_emojis(text: str) -> int:
+        return len([c for c in text if c in emoji.EMOJI_DATA])
     
-    text_lower = text.lower()
+    @staticmethod
+    def extract_mentions(text: str) -> List[str]:
+        return re.findall(r'@[\w\.]+', text)
     
-    # Подсчет индикаторов настроения
-    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)
+    @staticmethod
+    def get_words(text: str) -> List[str]:
+        return [w for w in re.findall(r'\w+', text.lower()) if len(w) > 2]
+
+class SentimentAnalyzer:
+    """Класс для анализа тональности"""
+    POSITIVE_INDICATORS = {
+        'emoji': ['🔥', '❤️', '👍', '😊', '💪', '👏', '🎉', '♥️', '😍', '🙏'],
+        'words': ['круто', 'супер', 'класс', 'огонь', 'пушка', 'отлично', 'здорово',
+                 'прекрасно', 'молодец', 'красота', 'спасибо', 'топ', 'лучший',
+                 'amazing', 'wonderful', 'great', 'perfect', 'love', 'beautiful']
+    }
     
-    # Учет восклицательных знаков
-    exclamation_count = text.count('!')
-    if positive_count > negative_count:
-        positive_count += exclamation_count * 0.5
-    elif negative_count > positive_count:
-        negative_count += exclamation_count * 0.5
+    NEGATIVE_INDICATORS = {
+        'emoji': ['👎', '😢', '😞', '😠', '😡', '💔', '😕', '😑'],
+        'words': ['плохо', 'ужас', 'отстой', 'фу', 'жесть', 'ужасно',
+                 'разочарован', 'печаль', 'грустно', 'bad', 'worst',
+                 'terrible', 'awful', 'sad', 'disappointed']
+    }
     
-    # Определение итогового настроения
-    if positive_count > negative_count:
-        return 'positive'
-    elif negative_count > positive_count:
-        return 'negative'
-    return 'neutral'
+    @classmethod
+    def analyze(cls, text: str) -> str:
+        text_lower = text.lower()
+        pos_count = sum(1 for ind in cls.POSITIVE_INDICATORS['emoji'] + cls.POSITIVE_INDICATORS['words'] 
+                       if ind in text_lower)
+        neg_count = sum(1 for ind in cls.NEGATIVE_INDICATORS['emoji'] + cls.NEGATIVE_INDICATORS['words'] 
+                       if ind in text_lower)
+        
+        exclamation_boost = text.count('!') * 0.5
+        if pos_count > neg_count:
+            pos_count += exclamation_boost
+        elif neg_count > pos_count:
+            neg_count += exclamation_boost
+            
+        return 'positive' if pos_count > neg_count else 'negative' if neg_count > pos_count else 'neutral'
 
-def extract_comment_data(comment_text):
-    """Извлекает данные из отдельного комментария с поддержкой различных форматов"""
-    try:
-        # Паттерны для извлечения данных
-        username_patterns = [
+class CommentExtractor:
+    """Класс для извлечения данных из комментариев"""
+    PATTERNS = {
+        'username': [
             r"Фото профиля ([^\n]+)",
             r"^([^\s]+)\s+",
-            r"@([^\s]+)\s+",
-        ]
-        
-        time_patterns = [
+            r"@([^\s]+)\s+"
+        ],
+        'time': [
             r"(\d+)\s*(?:ч|нед)\.",
             r"(\d+)\s*(?:h|w)",
-            r"(\d+)\s*(?:час|hour|week)",
-        ]
-        
-        likes_patterns = [
+            r"(\d+)\s*(?:час|hour|week)"
+        ],
+        'likes': [
             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"likes?: (\d+)"
+        ],
+        'metadata': [
             r"Фото профиля [^\n]+\n",
             r"\d+\s*(?:ч|нед|h|w|час|hour|week)\.",
             r"Нравится:?\s*\d+",
@@ -110,266 +89,198 @@ def extract_comment_data(comment_text):
             r"Ответить",
             r"Показать перевод",
             r"Скрыть все ответы",
-            r"Смотреть все ответы \(\d+\)",
-            username
+            r"Смотреть все ответы \(\d+\)"
         ]
+    }
+    
+    @classmethod
+    def extract_data(cls, comment_text: str) -> Tuple[Optional[str], Optional[str], int, float]:
+        try:
+            # Извлечение имени пользователя
+            username = None
+            for pattern in cls.PATTERNS['username']:
+                if match := re.search(pattern, comment_text):
+                    username = match.group(1).strip()
+                    break
+            
+            if not username:
+                return None, None, 0, 0
+                
+            # Очистка комментария
+            comment = comment_text
+            for pattern in cls.PATTERNS['metadata'] + [username]:
+                comment = re.sub(pattern, '', comment)
+            comment = TextAnalyzer.clean_text(comment)
+            
+            # Извлечение времени
+            weeks = 0
+            for pattern in cls.PATTERNS['time']:
+                if match := re.search(pattern, comment_text):
+                    time_value = int(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 cls.PATTERNS['likes']:
+                if match := re.search(pattern, comment_text):
+                    likes = int(match.group(1))
+                    break
+                    
+            return username, comment, likes, weeks
+            
+        except Exception as e:
+            logger.error(f"Error extracting comment data: {e}")
+            return None, None, 0, 0
+
+class StatsCalculator:
+    """Класс для расчета статистики"""
+    @staticmethod
+    def calculate_period_stats(weeks: List[float], likes: List[str], sentiments: List[str]) -> Dict:
+        if not weeks:
+            return {}
+            
+        earliest_week = max(weeks)
+        latest_week = min(weeks)
+        week_range = earliest_week - latest_week
         
-        for pattern in metadata_patterns:
-            comment = re.sub(pattern, '', comment)
+        period_length = week_range / 3 if week_range > 0 else 1
+        engagement_periods = {
+            'early': [],
+            'middle': [],
+            'late': []
+        }
         
-        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
+        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)
         
-    except Exception as e:
-        logger.error(f"Error extracting comment data: {e}")
-        return None, None, 0, 0
+        return {
+            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()
+        }
 
 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:
-        # Разделение на блоки комментариев
-        comment_patterns = [
+        # Разделение на комментарии
+        comment_patterns = '|'.join([
             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)"
-        ]
+        ])
+        comments_blocks = [block.strip() for block in re.split(comment_patterns, all_comments) 
+                         if block and block.strip() and 'Скрыто алгоритмами Instagram' not in block]
         
-        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()]
+        # Извлечение данных
+        data = [CommentExtractor.extract_data(block) for block in comments_blocks]
+        valid_data = [(u, c, l, w) for u, c, l, w in data if all((u, c))]
         
-        # Инициализация переменных для анализа
-        usernames = []
-        comments = []
-        likes = []
-        weeks = []
-        total_emojis = 0
-        mentions = []
-        sentiments = []
-        comment_lengths = []
-        words_per_comment = []
-        all_words = []
-        user_engagement = {}
-        
-        # Обработка комментариев
-        for block in comments_blocks:
-            if 'Скрыто алгоритмами Instagram' in block:
-                continue
-                
-            username, comment, like_count, week_number = extract_comment_data(block)
-            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)
-                sentiments.append(sentiment)
-                comment_lengths.append(len(comment))
-                
-                words = get_comment_words(comment)
-                words_per_comment.append(len(words))
-                all_words.extend(words)
-                
-                # Обновление статистики пользователя
-                if username not in user_engagement:
-                    user_engagement[username] = {
-                        'comments': 0,
-                        'total_likes': 0,
-                        'emoji_usage': 0,
-                        'avg_length': 0,
-                        'sentiments': [],
-                        'weeks': []
-                    }
-                    
-                user_stats = user_engagement[username]
-                user_stats['comments'] += 1
-                user_stats['total_likes'] += like_count
-                user_stats['emoji_usage'] += count_emojis(comment)
-                user_stats['avg_length'] += len(comment)
-                user_stats['sentiments'].append(sentiment)
-                user_stats['weeks'].append(week_number)
-        
-        # Расчет статистики
-        total_comments = len(comments)
-        if total_comments == 0:
+        if not valid_data:
             return "No comments found", "", "", "", "0"
             
-        # Обновление статистики пользователей
-        for username in user_engagement:
-            stats = user_engagement[username]
-            stats['avg_length'] /= stats['comments']
-            stats['engagement_rate'] = stats['total_likes'] / stats['comments']
-            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
+        usernames, comments, likes, weeks = zip(*valid_data)
+        likes = [str(l) for l in likes]
         
-        # Временной анализ
-        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 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
+        # Анализ комментариев
+        comment_stats = {
+            'lengths': [len(c) for c in comments],
+            'words': [len(TextAnalyzer.get_words(c)) for c in comments],
+            'emojis': sum(TextAnalyzer.count_emojis(c) for c in comments),
+            'mentions': [m for c in comments for m in TextAnalyzer.extract_mentions(c)],
+            'sentiments': [SentimentAnalyzer.analyze(c) for c in comments]
+        }
         
-        # Подготовка CSV
-        csv_data = {
-            'metadata': {
-                'content_type': content_type,
-                'link': link_to_post,
-                'post_likes': post_likes,
-                'post_date': post_date,
-                'total_comments': total_comments,
-                'expected_comments': comment_count
-            },
-            'basic_stats': {
-                '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': round(avg_likes, 2)
-            },
-            'sentiment_stats': dict(Counter(sentiments)),
-            'period_analysis': period_stats,
-            'top_users': dict(most_active_users),
-            'top_mentioned': dict(most_mentioned)
+        # Расчет базовой статистики
+        basic_stats = {
+            'total_comments': len(comments),
+            'avg_length': statistics.mean(comment_stats['lengths']),
+            'median_length': statistics.median(comment_stats['lengths']),
+            'avg_words': statistics.mean(comment_stats['words']),
+            'total_likes': sum(map(int, likes)),
+            'avg_likes': statistics.mean(map(int, likes))
         }
         
-        # Создание CSV строки
-        output = StringIO()
-        writer = csv.writer(output)
-        for section, data in csv_data.items():
-            writer.writerow([section])
-            for key, value in data.items():
-                writer.writerow([key, value])
-            writer.writerow([])
-        csv_output = output.getvalue()
+        # Расчет периодов
+        period_stats = StatsCalculator.calculate_period_stats(weeks, likes, comment_stats['sentiments'])
         
-        # Формирование отчета
-        analytics_summary = (
-            f"CSV DATA:\n{csv_output}\n\n"
-            f"ДЕТАЛЬНЫЙ АНАЛИЗ:\n"
-            f"Контент: {content_type}\n"
-            f"Ссылка: {link_to_post}\n\n"
-            f"СТАТИСТИКА:\n"
-            f"- Всего комментариев: {total_comments} (ожидалось: {comment_count})\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"
-            f"- Среднее слов: {avg_words_per_comment:.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"
-            + "\n".join([f"- {word}: {count}" for word, count in common_words]) + "\n\n"
-            f"АКТИВНЫЕ ПОЛЬЗОВАТЕЛИ:\n"
-            + "\n".join([f"- {user}: {count}" for user, count in most_active_users]) + "\n\n"
-            f"УПОМИНАНИЯ:\n"
-            + "\n".join([f"- {user}: {count}" for user, count in most_mentioned if user]) + "\n\n"
-            f"АНАЛИЗ ПО ПЕРИОДАМ:\n"
-            + "\n".join([f"- {period}: {stats['comments']} комментариев, {stats['avg_likes']:.1f} лайков/коммент, "
-                        f"{stats['sentiment_ratio']*100:.1f}% позитивных"
-                        for period, stats in period_stats.items()]) + "\n\n"
-            f"ЭКСПЕРИМЕНТАЛЬНАЯ АНАЛИТИКА:\n"
-            f"- Самый активный период: {max(period_stats.items(), key=lambda x: x[1]['comments'])[0]}\n"
-            f"- Наиболее позитивный период: {max(period_stats.items(), key=lambda x: x[1]['sentiment_ratio'])[0]}\n"
-            f"- Период с макс. вовлеченностью: {max(period_stats.items(), key=lambda x: x[1]['avg_likes'])[0]}"
+        # Создание отчета
+        csv_data = create_csv_report(content_type, link_to_post, post_likes, basic_stats,
+                                   comment_stats, period_stats, usernames, comment_stats['mentions'])
+        
+        analytics_summary = create_text_report(basic_stats, comment_stats, period_stats, csv_data)
+        
+        return (
+            analytics_summary,
+            "\n".join(usernames),
+            "\n".join(comments),
+            "\n".join(likes),
+            str(basic_stats['total_likes'])
         )
         
-        return analytics_summary, "\n".join(usernames), "\n".join(comments), "\n".join(likes), str(sum(map(int, likes)))
-    
     except Exception as e:
         logger.error(f"Error in analyze_post: {e}", exc_info=True)
         return f"Error: {str(e)}", "", "", "", "0"
 
-# Создаем интерфейс Gradio
+def create_csv_report(content_type, link, post_likes, basic_stats, comment_stats, period_stats, usernames, mentions):
+    """Создание CSV отчета"""
+    csv_data = {
+        'metadata': {
+            'content_type': content_type,
+            'link': link,
+            'post_likes': post_likes
+        },
+        'basic_stats': basic_stats,
+        'sentiment_stats': dict(Counter(comment_stats['sentiments'])),
+        'period_analysis': period_stats,
+        'top_users': dict(Counter(usernames).most_common(5)),
+        'top_mentioned': dict(Counter(mentions).most_common(5))
+    }
+    
+    output = StringIO()
+    writer = csv.writer(output)
+    for section, data in csv_data.items():
+        writer.writerow([section])
+        for key, value in data.items():
+            writer.writerow([key, value])
+        writer.writerow([])
+    return output.getvalue()
+
+def create_text_report(basic_stats, comment_stats, period_stats, csv_data):
+    """Создание текстового отчета"""
+    sentiment_dist = Counter(comment_stats['sentiments'])
+    return (
+        f"CSV DATA:\n{csv_data}\n\n"
+        f"СТАТИСТИКА:\n"
+        f"- Всего комментариев: {basic_stats['total_comments']}\n"
+        f"- Среднее лайков: {basic_stats['avg_likes']:.1f}\n"
+        f"АНАЛИЗ КОНТЕНТА:\n"
+        f"- Средняя длина: {basic_stats['avg_length']:.1f}\n"
+        f"- Медиана длины: {basic_stats['median_length']}\n"
+        f"- Среднее слов: {basic_stats['avg_words']:.1f}\n"
+        f"- Эмодзи: {comment_stats['emojis']}\n"
+        f"ТОНАЛЬНОСТЬ:\n"
+        f"- Позитив: {sentiment_dist['positive']}\n"
+        f"- Нейтрально: {sentiment_dist['neutral']}\n"
+        f"- Негатив: {sentiment_dist['negative']}\n"
+    )
+
+# Создание интерфейса Gradio
+import gradio as gr
+
 iface = gr.Interface(
     fn=analyze_post,
     inputs=[
@@ -389,7 +300,7 @@ iface = gr.Interface(
         gr.Textbox(label="Total Likes on Comments")
     ],
     title="Enhanced Instagram Comment Analyzer",
-    description="Анализатор комментариев Instagram с расширенной аналитикой и CSV-форматированием"
+    description="Анализатор комментариев Instagram с расширенной аналитикой"
 )
 
 if __name__ == "__main__":