Update app.py

app.py

@@ -7,8 +7,7 @@ import logging
 from typing import Tuple, List, Optional
 import statistics
 import csv
-from textblob import TextBlob
-import numpy as np
+from io import StringIO
 
 # Настройка логирования
 logging.basicConfig(level=logging.INFO)
@@ -35,7 +34,7 @@ def analyze_sentiment(text):
     """Расширенный анализ тональности по эмодзи и ключевым словам"""
     positive_indicators = ['🔥', '❤️', '👍', '😊', '💪', '👏', '🎉', '♥️', '😍', '🙏',
                          'круто', 'супер', 'класс', 'огонь', 'пушка', 'отлично', 'здорово',
-                         'прекрасно', 'молодец', 'красота', 'спасибо', 'топ']
+                         'прекрасно', 'молодец', 'красота', 'спасибо', 'топ', 'лучший']
     negative_indicators = ['👎', '😢', '😞', '😠', '😡', '💔', '😕', '😑', 
                          'плохо', 'ужас', 'отстой', 'фу', 'жесть', 'ужасно',
                          'разочарован', 'печаль', 'грустно']
@@ -48,38 +47,26 @@ def analyze_sentiment(text):
     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
     
-    # Добавляем анализ через TextBlob для более точной оценки
-    blob = TextBlob(text)
-    sentiment_score = blob.sentiment.polarity
-    
-    # Комбинируем оба подхода
-    final_score = (positive_count - negative_count) + sentiment_score
-    
-    if final_score > 0:
+    if positive_count > negative_count:
         return 'positive'
-    elif final_score < 0:
+    elif negative_count > positive_count:
         return 'negative'
     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:
@@ -89,16 +76,13 @@ def extract_comment_data(comment_text):
         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+)",
-            r"\"Нравится\": (\d+)",
         ]
         
         for pattern in likes_patterns:
@@ -118,13 +102,14 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
         comments_blocks = re.split(r'(?=Фото профиля|Скрыто алгоритмами Instagram)', all_comments)
         comments_blocks = [block for block in comments_blocks if block.strip()]
         
-        # Основные списки для данных
+        # Подсчет скрытых комментариев
+        hidden_comments = len(re.findall(r'Скрыто алгоритмами Instagram', all_comments))
+        
         usernames = []
         comments = []
         likes = []
         weeks = []
         
-        # Дополнительные метрики
         total_emojis = 0
         mentions = []
         sentiments = []
@@ -132,11 +117,12 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
         words_per_comment = []
         all_words = []
         user_engagement = {}
-        reply_chains = []
-        current_chain = []
         
-        # Обработка каждого комментария
+        # Обработка комментариев
         for block in comments_blocks:
+            if 'Скрыто алгоритмами Instagram' in block:
+                continue
+                
             username, comment, like_count, week_number = extract_comment_data(block)
             if username and (comment is not None):
                 usernames.append(username)
@@ -144,28 +130,16 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                 likes.append(str(like_count))
                 weeks.append(week_number)
                 
-                # Базовые метрики
                 total_emojis += count_emojis(comment)
-                comment_mentions = extract_mentions(comment)
-                mentions.extend(comment_mentions)
+                mentions.extend(extract_mentions(comment))
                 sentiment = analyze_sentiment(comment)
                 sentiments.append(sentiment)
                 comment_lengths.append(len(comment))
                 
-                # Анализ цепочек ответов
-                if comment_mentions:
-                    current_chain.append((username, comment_mentions[0]))
-                else:
-                    if current_chain:
-                        reply_chains.append(current_chain)
-                        current_chain = []
-                
-                # Расширенные метрики
                 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,
@@ -173,9 +147,7 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                         'emoji_usage': 0,
                         'avg_length': 0,
                         'sentiments': [],
-                        'mentions_received': 0,
-                        'mentions_made': len(comment_mentions),
-                        'response_time': []
+                        'weeks': []  # Добавлено для анализа временной активности
                     }
                 user_stats = user_engagement[username]
                 user_stats['comments'] += 1
@@ -183,74 +155,141 @@ def analyze_post(content_type, link_to_post, post_likes, post_date, description,
                 user_stats['emoji_usage'] += count_emojis(comment)
                 user_stats['avg_length'] += len(comment)
                 user_stats['sentiments'].append(sentiment)
+                user_stats['weeks'].append(week_number)
         
-        # Финализируем цепочки ответов
-        if current_chain:
-            reply_chains.append(current_chain)
-        
-        # Обновляем статистику пользователей
+        # Проверка количества комментариев
+        total_comments = len(comments)
+        if total_comments != comment_count:
+            logger.warning(f"Found {total_comments} comments, but expected {comment_count}")
+            
+        # Обновление статистики пользователей
         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['mentions_received'] = sum(1 for m in mentions if m == f'@{username}')
+            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)
         
         # Экспериментальная аналитика
-        experimental_metrics = {
-            'conversation_depth': len(max(reply_chains, key=len)) if reply_chains else 0,
-            'avg_response_time': np.mean([c['avg_length'] for c in user_engagement.values()]),
-            'engagement_consistency': np.std([c['comments'] for c in user_engagement.values()]),
-            'user_interaction_score': len([c for c in comments if any(mention in c for mention in mentions)]) / len(comments),
-            'sentiment_volatility': np.std([1 if s == 'positive' else -1 if s == 'negative' else 0 for s in sentiments]),
+        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
+            }
+            for period, indices in engagement_periods.items()
         }
         
-        # Форматируем данные для CSV
+        # Подготовка данных для CSV
         csv_data = {
-            'post_url': link_to_post,
-            'total_comments': len(comments),
-            'total_likes': sum(map(int, likes)),
-            'avg_likes_per_comment': sum(map(int, likes)) / len(comments),
-            'unique_users': len(set(usernames)),
-            'emoji_rate': total_emojis / len(comments),
-            'avg_comment_length': sum(comment_lengths) / len(comments),
-            'positive_sentiment_ratio': sum(1 for s in sentiments if s == 'positive') / len(sentiments),
-            'mention_rate': len(mentions) / len(comments),
-            'conversation_depth': experimental_metrics['conversation_depth'],
-            'user_interaction_score': experimental_metrics['user_interaction_score'],
-            'sentiment_volatility': experimental_metrics['sentiment_volatility'],
+            '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,
+                'hidden_comments': hidden_comments
+            },
+            'basic_stats': {
+                'avg_comment_length': avg_comment_length,
+                'median_comment_length': median_comment_length,
+                'avg_words': avg_words_per_comment,
+                'total_emojis': total_emojis,
+                'avg_likes': avg_likes
+            },
+            'sentiment_stats': {
+                'positive': sentiment_distribution['positive'],
+                'neutral': sentiment_distribution['neutral'],
+                'negative': sentiment_distribution['negative']
+            },
+            'period_analysis': period_stats,
+            'top_users': dict(most_active_users),
+            'top_mentioned': dict(most_mentioned)
         }
         
-        # Форматируем вывод для CSV
-        csv_output = ",".join([f"{k}:{v}" for k, v in csv_data.items()])
+        # Создаем 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()
         
-        # Форматируем детальную аналитику
+        # Формируем текстовый отчет
         analytics_summary = (
-            f"CSV_DATA\n{csv_output}\n\n"
-            f"DETAILED_ANALYTICS\n"
-            f"Content Type: {content_type}\n"
-            f"Link to Post: {link_to_post}\n\n"
-            f"BASIC_STATS\n"
-            f"Total Comments: {len(comments)}\n"
-            f"Total Likes: {sum(map(int, likes))}\n"
-            f"Unique Users: {len(set(usernames))}\n"
-            f"Activity Period: {max(weeks)}-{min(weeks)} weeks\n\n"
-            f"CONTENT_ANALYSIS\n"
-            f"Avg Comment Length: {sum(comment_lengths) / len(comments):.1f}\n"
-            f"Total Emojis: {total_emojis}\n"
-            f"Sentiment Distribution: {Counter(sentiments)}\n\n"
-            f"EXPERIMENTAL_METRICS\n"
-            f"Conversation Depth: {experimental_metrics['conversation_depth']}\n"
-            f"User Interaction Score: {experimental_metrics['user_interaction_score']:.2f}\n"
-            f"Sentiment Volatility: {experimental_metrics['sentiment_volatility']:.2f}\n"
-            f"Engagement Consistency: {experimental_metrics['engagement_consistency']:.2f}\n"
+            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"- Скрытых комментариев: {hidden_comments}\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"- Медиана длины: {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]}"
         )
         
-        return analytics_summary, usernames_output, comments_output, likes_chronology_output, str(sum(map(int, 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 str(e), "", "", "", "0"
+        return f"Error: {str(e)}", "", "", "", "0"
 
 # Создаем интерфейс Gradio
 iface = gr.Interface(