Update app.py

app.py

@@ -3,203 +3,250 @@ import re
 from collections import Counter
 from datetime import datetime
 import emoji
+from transformers import pipeline
+import logging
+from typing import Tuple, List, Optional
 
-def clean_text(text):
-    """Очищает текст от лишних пробелов и переносов строк"""
-    return ' '.join(text.split())
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def count_emojis(text):
-    """Подсчитывает количество эмодзи в тексте"""
-    return len([c for c in text if c in emoji.EMOJI_DATA])
+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 extract_mentions(text):
-    """Извлекает упоминания пользователей из текста"""
-    return re.findall(r'@[\w\.]+', text)
+        # 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 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)
-    
-    if positive_count > negative_count:
-        return 'positive'
-    elif negative_count > positive_count:
-        return 'negative'
-    return 'neutral'
-
-def extract_comment_data(comment_text):
-    """
-    Извлекает данные из отдельного комментария
-    Возвращает (username, comment_text, likes_count, week_number)
-    """
-    # Извлекаем имя пользователя
-    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"{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
+    def clean_text(self, text: str) -> str:
+        """Clean text by removing extra whitespace and normalizing line breaks"""
+        return ' '.join(text.split())
 
-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 = []
-        
-        # Обработка каждого комментария
-        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)
-                
-                # Сбор дополнительных метрик
-                total_emojis += count_emojis(comment)
-                mentions.extend(extract_mentions(comment))
-                sentiments.append(analyze_sentiment(comment))
-                comment_lengths.append(len(comment))
-        
-        # Аналитика
-        total_comments = len(comments)
-        avg_comment_length = sum(comment_lengths) / total_comments if comment_lengths else 0
-        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
-        
-        # Формируем выходные данные
-        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"- Всего эмодзи использовано: {total_emojis}\n"
-            f"- Тональность комментариев:\n"
-            f"  * Позитивных: {sentiment_distribution['positive']}\n"
-            f"  * Нейтральных: {sentiment_distribution['neutral']}\n"
-            f"  * Негативных: {sentiment_distribution['negative']}\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"- Процент комментариев с лайками: {(sum(1 for l in likes if int(l) > 0) / total_comments * 100):.1f}%\n"
-            f"- Процент комментариев с эмодзи: {(sum(1 for c in comments if count_emojis(c) > 0) / total_comments * 100):.1f}%\n"
+    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(self, text: str) -> List[str]:
+        """Extract @mentions from text"""
+        return self.mention_pattern.findall(text)
+
+    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 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:
+            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)
         )
+
+    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
         
-        return analytics_summary, usernames_output, comments_output, likes_chronology_output, str(total_likes_sum)
+        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")
+                
+            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'])
+            )
+            
+        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()
     
-    except Exception as e:
-        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 с детальной аналитикой"
-)
+    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
 
 if __name__ == "__main__":
+    iface = create_interface()
     iface.launch()