Update app.py

app.py

@@ -3,250 +3,293 @@ import re
 from collections import Counter
 from datetime import datetime
 import emoji
-from transformers import pipeline
 import logging
 from typing import Tuple, List, Optional
+import statistics
 
-# Set up logging
+# Настройка логирования
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class CommentAnalyzer:
-    def __init__(self):
-        """Initialize the analyzer with sentiment model and compile regex patterns"""
-        try:
-            self.sentiment_model = pipeline("sentiment-analysis")
-        except Exception as e:
-            logger.error(f"Failed to load sentiment model: {e}")
-            raise
+def clean_text(text):
+    """Очищает текст от лишних пробелов и переносов строк"""
+    return ' '.join(text.split())
 
-        # Compile regex patterns for better performance
-        self.mention_pattern = re.compile(r'@[\w\.]+')
-        self.comment_pattern = re.compile(
-            r'Фото профиля\s+(.+?)\s+'  # Username
-            r'((?:(?!Фото профиля).)+?)\s+'  # Comment text
-            r'(\d+)?\s*(?:нравится|like[s]?)?\s*'  # Likes count
-            r'(\d+)\s*(?:н|w)'  # Week number
-            , re.DOTALL
-        )
-
-    def clean_text(self, text: str) -> str:
-        """Clean text by removing extra whitespace and normalizing line breaks"""
-        return ' '.join(text.split())
+def count_emojis(text):
+    """Подсчитывает количество эмодзи в тексте"""
+    return len([c for c in text if c in emoji.EMOJI_DATA])
 
-    def count_emojis(self, text: str) -> int:
-        """Count the number of emoji characters in 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 extract_mentions(self, text: str) -> List[str]:
-        """Extract @mentions from text"""
-        return self.mention_pattern.findall(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(self, text: str) -> str:
-        """Analyze text sentiment using the loaded model"""
-        try:
-            result = self.sentiment_model(text[:512])  # Limit text length for model
-            sentiment = result[0]['label']
-            if sentiment == 'POSITIVE':
-                return 'positive'
-            elif sentiment == 'NEGATIVE':
-                return 'negative'
-            return 'neutral'
-        except Exception as e:
-            logger.warning(f"Sentiment analysis failed: {e}")
-            return 'neutral'
+def analyze_sentiment(text):
+    """Расширенный анализ тональности по эмодзи и ключевым словам"""
+    positive_indicators = ['🔥', '❤️', '👍', '😊', '💪', '👏', '🎉', '♥️', '😍', '🙏',
+                         'круто', 'супер', 'класс', 'огонь', 'пушка', 'отлично', 'здорово',
+                         'прекрасно', 'молодец', 'красота', 'спасибо', 'топ']
+    negative_indicators = ['👎', '😢', '😞', '😠', '😡', '💔', '😕', '😑', 
+                         'плохо', 'ужас', 'отстой', 'фу', 'жесть', 'ужасно',
+                         'разочарован', 'печаль', 'грустно']
+    
+    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:
+        return 'positive'
+    elif negative_count > positive_count:
+        return 'negative'
+    return 'neutral'
 
-    def extract_comment_data(self, comment_block: str) -> Tuple[Optional[str], Optional[str], int, int]:
-        """
-        Extract structured data from a comment block
-        Returns: (username, comment_text, likes_count, week_number)
-        """
-        match = self.comment_pattern.search(comment_block)
-        if not match:
+def extract_comment_data(comment_text):
+    """
+    Извлекает данные из отдельного комментария
+    Возвращает (username, comment_text, likes_count, week_number)
+    """
+    try:
+        # Извлекаем имя пользователя
+        username_match = re.search(r"Фото профиля ([^\n]+)", comment_text)
+        if not username_match:
             return None, None, 0, 0
-            
-        username, comment, likes, week = match.groups()
-        return (
-            username.strip(),
-            self.clean_text(comment),
-            int(likes or 0),
-            int(week or 0)
-        )
+        
+        username = username_match.group(1).strip()
+        
+        # Извлекаем текст комментария
+        comment_pattern = fr"{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'^{username}\s*', '', comment)
+            comment = re.sub(r'^@[\w\.]+ ', '', comment)
+        else:
+            comment = ""
+        
+        # Извлекаем количество недель
+        week_match = re.search(r'(\d+) нед\.', comment_text)
+        weeks = int(week_match.group(1)) if week_match else 0
+        
+        # Ищем количество лайков
+        likes = 0
+        likes_patterns = [
+            r"(\d+) отметк[аи] \"Нравится\"",
+            r"Нравится: (\d+)",
+        ]
+        
+        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(self, 
-                    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]:
-        """
-        Analyze Instagram post comments and generate comprehensive analytics
-        
-        Args:
-            content_type: Type of content ("Photo" or "Video")
-            link_to_post: URL of the post
-            post_likes: Number of likes on the post
-            post_date: Date of post publication
-            description: Post description/caption
-            comment_count: Total number of comments
-            all_comments: Raw text containing all comments
-            
-        Returns:
-            Tuple containing:
-            - Analytics summary
-            - List of usernames
-            - List of comments
-            - Chronological list of likes
-            - Total likes count
-        """
-        try:
-            # Split comments into blocks
-            comments_blocks = [block for block in re.split(r'(?=Фото профиля)', all_comments) if block.strip()]
-            
-            # Initialize data containers
-            data = {
-                'usernames': [],
-                'comments': [],
-                'likes': [],
-                'weeks': [],
-                'emojis': 0,
-                'mentions': [],
-                'sentiments': [],
-                'lengths': []
-            }
-            
-            # Process each comment block
-            for block in comments_blocks:
-                username, comment, like_count, week = self.extract_comment_data(block)
-                if username and comment:
-                    data['usernames'].append(username)
-                    data['comments'].append(comment)
-                    data['likes'].append(like_count)
-                    data['weeks'].append(week)
-                    
-                    # Collect metrics
-                    data['emojis'] += self.count_emojis(comment)
-                    data['mentions'].extend(self.extract_mentions(comment))
-                    data['sentiments'].append(self.analyze_sentiment(comment))
-                    data['lengths'].append(len(comment))
-            
-            # Calculate analytics
-            total_comments = len(data['comments'])
-            if total_comments == 0:
-                raise ValueError("No valid comments found in input")
+def analyze_post(content_type, link_to_post, post_likes, post_date, description, comment_count, all_comments):
+    try:
+        # Разделяем комментарии по "Фото профиля"
+        comments_blocks = re.split(r'(?=Фото профиля)', all_comments)
+        comments_blocks = [block for block in comments_blocks if block.strip()]
+        
+        # Основные списки для данных
+        usernames = []
+        comments = []
+        likes = []
+        weeks = []
+        
+        # Дополнительные метрики
+        total_emojis = 0
+        mentions = []
+        sentiments = []
+        comment_lengths = []
+        words_per_comment = []
+        all_words = []
+        user_engagement = {}  # Словарь для хранения статистики по пользователям
+        
+        # Обработка каждого комментария
+        for block in comments_blocks:
+            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)
                 
-            analytics = {
-                'avg_length': sum(data['lengths']) / total_comments,
-                'sentiment_dist': Counter(data['sentiments']),
-                'active_users': Counter(data['usernames']).most_common(5),
-                'top_mentions': Counter(data['mentions']).most_common(5),
-                'avg_likes': sum(data['likes']) / total_comments,
-                'weeks_range': (min(data['weeks']), max(data['weeks'])),
-                'total_likes': sum(data['likes'])
-            }
-            
-            # Generate summary
-            summary = self._format_analytics_summary(
-                content_type, link_to_post, data, analytics, total_comments
-            )
-            
-            return (
-                summary,
-                '\n'.join(data['usernames']),
-                '\n'.join(data['comments']),
-                '\n'.join(map(str, data['likes'])),
-                str(analytics['total_likes'])
-            )
+                # Базовые метрики
+                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': []
+                    }
+                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)
+        
+        # Аналитика
+        total_comments = len(comments)
+        if total_comments == 0:
+            raise ValueError("No valid comments found")
             
-        except Exception as e:
-            logger.error(f"Error analyzing post: {e}", exc_info=True)
-            return (f"Error during analysis: {str(e)}", "", "", "", "0")
-
-    def _format_analytics_summary(self, content_type, link, data, analytics, total_comments):
-        """Format analytics data into a readable summary"""
-        return f"""
-Content Type: {content_type}
-Link to Post: {link}
-
-ОСНОВНАЯ СТАТИСТИКА:
-- Всего комментариев: {total_comments}
-- Всего лайков на комментариях: {analytics['total_likes']}
-- Среднее количество лайков: {analytics['avg_likes']:.1f}
-- Период активности: {analytics['weeks_range'][0]}-{analytics['weeks_range'][1]} недель
-
-АНАЛИЗ КОНТЕНТА:
-- Средняя длина комментария: {analytics['avg_length']:.1f} символов
-- Всего эмодзи использовано: {data['emojis']}
-- Тональность комментариев:
-  * Позитивных: {analytics['sentiment_dist']['positive']}
-  * Нейтральных: {analytics['sentiment_dist']['neutral']}
-  * Негативных: {analytics['sentiment_dist']['negative']}
-
-АКТИВНОСТЬ ПОЛЬЗОВАТЕЛЕЙ:
-Самые активные комментаторы:
-{chr(10).join(f"- {user}: {count} комментариев" for user, count in analytics['active_users'])}
-
-Самые упоминаемые пользователи:
-{chr(10).join(f"- {user}: {count} упоминаний" for user, count in analytics['top_mentions'] if user)}
-
-ВОВЛЕЧЕННОСТЬ:
-- Процент комментариев с лайками: {(sum(1 for l in data['likes'] if l > 0) / total_comments * 100):.1f}%
-- Процент комментариев с эмодзи: {(sum(1 for c in data['comments'] if self.count_emojis(c) > 0) / total_comments * 100):.1f}%
-"""
-
-def create_interface():
-    """Create and configure the Gradio interface"""
-    analyzer = CommentAnalyzer()
+        # Обновляем статистику пользователей
+        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'])
+        
+        # Базовая статистика
+        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_metrics = {
+            'comments_with_likes': sum(1 for l in likes if int(l) > 0),
+            'comments_with_emoji': sum(1 for c in comments if count_emojis(c) > 0),
+            'comments_with_mentions': sum(1 for c in comments if extract_mentions(c)),
+            'avg_engagement_rate': statistics.mean([
+                stats['engagement_rate'] for stats in user_engagement.values()
+            ])
+        }
+        
+        # Временной анализ
+        week_distribution = Counter(weeks)
+        most_active_weeks = sorted(week_distribution.items(), key=lambda x: x[1], reverse=True)[:3]
+        
+        # Формируем выходные данные
+        usernames_output = "\n".join(usernames)
+        comments_output = "\n".join(comments)
+        likes_chronology_output = "\n".join(likes)
+        total_likes_sum = sum(map(int, likes))
+        
+        # Расширенная аналитика
+        analytics_summary = (
+            f"Content Type: {content_type}\n"
+            f"Link to Post: {link_to_post}\n\n"
+            f"ОСНОВНАЯ СТАТИСТИКА:\n"
+            f"- Всего комментариев: {total_comments}\n"
+            f"- Всего лайков на комментариях: {total_likes_sum}\n"
+            f"- Среднее количество лайков: {avg_likes:.1f}\n"
+            f"- Период активности: {earliest_week}-{latest_week} недель\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"
+            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"
+            f"- Процент комментариев с лайками: {(engagement_metrics['comments_with_likes'] / total_comments * 100):.1f}%\n"
+            f"- Процент комментариев с эмодзи: {(engagement_metrics['comments_with_emoji'] / total_comments * 100):.1f}%\n"
+            f"- Процент комментариев с упоминаниями: {(engagement_metrics['comments_with_mentions'] / total_comments * 100):.1f}%\n"
+            f"- Средний рейтинг вовлеченности: {engagement_metrics['avg_engagement_rate']:.2f}\n\n"
+            f"ВРЕМЕННАЯ АКТИВНОСТЬ:\n"
+            f"Самые активные недели:\n"
+            + "\n".join([f"- {week} неделя: {count} комментариев" for week, count in most_active_weeks])
+        )
+        
+        return analytics_summary, usernames_output, comments_output, likes_chronology_output, str(total_likes_sum)
     
-    iface = gr.Interface(
-        fn=analyzer.analyze_post,
-        inputs=[
-            gr.Radio(
-                choices=["Photo", "Video"],
-                label="Content Type",
-                value="Photo"
-            ),
-            gr.Textbox(
-                label="Link to Post",
-                placeholder="Введите ссылку на пост"
-            ),
-            gr.Number(
-                label="Likes",
-                value=0
-            ),
-            gr.Textbox(
-                label="Post Date",
-                placeholder="Введите дату публикации"
-            ),
-            gr.Textbox(
-                label="Description",
-                placeholder="Введите описание поста",
-                lines=3
-            ),
-            gr.Number(
-                label="Total Comment Count",
-                value=0
-            ),
-            gr.Textbox(
-                label="All Comments",
-                placeholder="Вставьте комментарии",
-                lines=10
-            )
-        ],
-        outputs=[
-            gr.Textbox(label="Analytics Summary", lines=20),
-            gr.Textbox(label="Usernames (Output 1)", lines=5),
-            gr.Textbox(label="Comments (Output 2)", lines=5),
-            gr.Textbox(label="Likes Chronology (Output 3)", lines=5),
-            gr.Textbox(label="Total Likes on Comments (Output 4)")
-        ],
-        title="Instagram Comment Analyzer Pro",
-        description="Расширенный анализатор комментариев Instagram с детальной аналитикой"
-    )
-    return iface
+    except Exception as e:
+        logger.error(f"Error in analyze_post: {e}", exc_info=True)
+        error_message = f"Произошла ошибка при обработке: {str(e)}\n{str(type(e))}"
+        return error_message, error_message, error_message, error_message, "0"
+
+# Создаем интерфейс Gradio
+iface = gr.Interface(
+    fn=analyze_post,
+    inputs=[
+        gr.Radio(
+            choices=["Photo", "Video"],
+            label="Content Type",
+            value="Photo"
+        ),
+        gr.Textbox(
+            label="Link to Post",
+            placeholder="Введите ссылку на пост"
+        ),
+        gr.Number(
+            label="Likes",
+            value=0
+        ),
+        gr.Textbox(
+            label="Post Date",
+            placeholder="Введите дату публикации"
+        ),
+        gr.Textbox(
+            label="Description",
+            placeholder="Введите описание поста",
+            lines=3
+        ),
+        gr.Number(
+            label="Total Comment Count",
+            value=0
+        ),
+        gr.Textbox(
+            label="All Comments",
+            placeholder="Вставьте комментарии",
+            lines=10
+        )
+    ],
+    outputs=[
+        gr.Textbox(label="Analytics Summary", lines=20),
+        gr.Textbox(label="Usernames (Output 1)", lines=5),
+        gr.Textbox(label="Comments (Output 2)", lines=5),
+        gr.Textbox(label="Likes Chronology (Output 3)", lines=5),
+        gr.Textbox(label="Total Likes on Comments (Output 4)")
+    ],
+    title="Instagram Comment Analyzer Pro",
+    description="Расширенный анализатор комментариев Instagram с детальной аналитикой"
+)
 
 if __name__ == "__main__":
-    iface = create_interface()
     iface.launch()