smart-bot-factory 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

smart_bot_factory/integrations/supabase_client.py

@@ -52,15 +52,65 @@ class SupabaseClient:
             response = query.execute()
             
             if response.data:
-                # Обновляем данные существующего пользователя
-                update_query = self.client.table('sales_users').update({
+                # Получаем текущие данные пользователя для мержинга UTM и сегментов
+                existing_user_query = self.client.table('sales_users').select(
+                    'source', 'medium', 'campaign', 'content', 'term', 'segments'
+                ).eq('telegram_id', user_data['telegram_id'])
+                
+                if self.bot_id:
+                    existing_user_query = existing_user_query.eq('bot_id', self.bot_id)
+                
+                existing_response = existing_user_query.execute()
+                existing_utm = existing_response.data[0] if existing_response.data else {}
+                
+                # Формируем данные для обновления
+                update_data = {
                     'username': user_data.get('username'),
                     'first_name': user_data.get('first_name'),
                     'last_name': user_data.get('last_name'),
                     'language_code': user_data.get('language_code'),
                     'updated_at': datetime.now().isoformat(),
                     'is_active': True
-                }).eq('telegram_id', user_data['telegram_id'])
+                }
+                
+                # Мержим UTM данные: обновляем только если новое значение не None
+                utm_fields = ['source', 'medium', 'campaign', 'content', 'term']
+                for field in utm_fields:
+                    new_value = user_data.get(field)
+                    if new_value is not None:
+                        # Есть новое значение - обновляем
+                        update_data[field] = new_value
+                        if existing_utm.get(field) != new_value:
+                            logger.info(f"📊 UTM обновление: {field} = '{new_value}' (было: '{existing_utm.get(field)}')")
+                    else:
+                        # Нового значения нет - сохраняем старое
+                        update_data[field] = existing_utm.get(field)
+                
+                # Обрабатываем сегменты с накоплением через запятую
+                new_segment = user_data.get('segment')
+                if new_segment:
+                    existing_segments = existing_utm.get('segments', '') or ''
+                    if existing_segments:
+                        # Разбираем существующие сегменты
+                        segments_list = [s.strip() for s in existing_segments.split(',') if s.strip()]
+                        # Добавляем новый сегмент, если его еще нет
+                        if new_segment not in segments_list:
+                            segments_list.append(new_segment)
+                            update_data['segments'] = ', '.join(segments_list)
+                            logger.info(f"📊 Сегмент добавлен: '{new_segment}' (было: '{existing_segments}')")
+                        else:
+                            update_data['segments'] = existing_segments
+                            logger.info(f"📊 Сегмент '{new_segment}' уже существует")
+                    else:
+                        # Первый сегмент
+                        update_data['segments'] = new_segment
+                        logger.info(f"📊 Первый сегмент добавлен: '{new_segment}'")
+                else:
+                    # Нового сегмента нет - сохраняем старое значение
+                    update_data['segments'] = existing_utm.get('segments')
+                
+                # Обновляем пользователя
+                update_query = self.client.table('sales_users').update(update_data).eq('telegram_id', user_data['telegram_id'])
                 
                 if self.bot_id:
                     update_query = update_query.eq('bot_id', self.bot_id)
@@ -83,13 +133,17 @@ class SupabaseClient:
                     'campaign': user_data.get('campaign'),
                     'content': user_data.get('content'),
                     'term': user_data.get('term'),
+                    'segments': user_data.get('segment'),  # Первый сегмент при создании
                 }
                 if self.bot_id:
                     user_insert_data['bot_id'] = self.bot_id
                 
                 response = self.client.table('sales_users').insert(user_insert_data).execute()
                 
-                logger.info(f"Создан новый пользователь {user_data['telegram_id']}{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
+                if user_data.get('segment'):
+                    logger.info(f"Создан новый пользователь {user_data['telegram_id']} с сегментом '{user_data.get('segment')}'{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
+                else:
+                    logger.info(f"Создан новый пользователь {user_data['telegram_id']}{f' для bot_id {self.bot_id}' if self.bot_id else ''}")
                 return user_data['telegram_id']
                 
         except APIError as e:
@@ -730,47 +784,71 @@ class SupabaseClient:
     async def get_funnel_stats(self, days: int = 7) -> Dict[str, Any]:
         """Получает статистику воронки продаж"""
         try:
-            cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+            cutoff_date = datetime.now() - timedelta(days=days)
+            
+                        # Получаем ВСЕ уникальные пользователи из sales_users с фильтром по bot_id
+            users_query = self.client.table('sales_users').select('telegram_id')
             
-            # Общее количество сессий
-            sessions_response = self.client.table('sales_chat_sessions').select('id').gte(
-                'created_at', cutoff_date.isoformat()
-            )
             if self.bot_id:
-                sessions_response = sessions_response.eq('bot_id', self.bot_id)
+                users_query = users_query.eq('bot_id', self.bot_id)
             
-            total_sessions = len(sessions_response.execute().data)
+            # Исключаем тестовых пользователей
+            users_query = users_query.neq('username', 'test_user')
             
-            # Статистика по этапам
-            stages_response = self.client.table('sales_chat_sessions').select(
-                'current_stage', 'quality_score'
-            ).gte('created_at', cutoff_date.isoformat())
+            users_response = users_query.execute()
+            total_unique_users = len(users_response.data) if users_response.data else 0
             
+            # Получаем сессии с учетом bot_id за период
+            sessions_query = self.client.table('sales_chat_sessions').select(
+                'id', 'user_id', 'current_stage', 'lead_quality_score', 'created_at'
+            ).gte('created_at', cutoff_date.isoformat())
+
             if self.bot_id:
-                stages_response = stages_response.eq('bot_id', self.bot_id)
+                sessions_query = sessions_query.eq('bot_id', self.bot_id)
+
+            sessions_response = sessions_query.execute()
+            sessions = sessions_response.data
+            
+            # Исключаем сессии тестовых пользователей
+            if sessions:
+                # Получаем telegram_id тестовых пользователей
+                test_users_query = self.client.table('sales_users').select('telegram_id').eq('username', 'test_user')
+                if self.bot_id:
+                    test_users_query = test_users_query.eq('bot_id', self.bot_id)
+                
+                test_users_response = test_users_query.execute()
+                test_user_ids = {user['telegram_id'] for user in test_users_response.data} if test_users_response.data else set()
+                
+                # Фильтруем сессии
+                sessions = [s for s in sessions if s['user_id'] not in test_user_ids]
             
-            sessions_data = stages_response.execute().data
+            total_sessions = len(sessions)
+
+            # Группировка по этапам
             
+            # Группировка по этапам
             stages = {}
             quality_scores = []
             
-            for session in sessions_data:
+            for session in sessions:
                 stage = session.get('current_stage', 'unknown')
                 stages[stage] = stages.get(stage, 0) + 1
                 
-                if session.get('quality_score'):
-                    quality_scores.append(session['quality_score'])
+                score = session.get('lead_quality_score', 5)
+                if score:
+                    quality_scores.append(score)
             
-            avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+            avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 5
             
             return {
                 'total_sessions': total_sessions,
+                'total_unique_users': total_unique_users,  # ✅ ВСЕ уникальные пользователи бота
                 'stages': stages,
-                'avg_quality': round(avg_quality, 2),
+                'avg_quality': round(avg_quality, 1),
                 'period_days': days
             }
-            
-        except Exception as e:
+             
+        except APIError as e:
             logger.error(f"Ошибка получения статистики воронки: {e}")
             return {
                 'total_sessions': 0,
@@ -782,25 +860,50 @@ class SupabaseClient:
     async def get_events_stats(self, days: int = 7) -> Dict[str, int]:
         """Получает статистику событий"""
         try:
-            cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+            cutoff_date = datetime.now() - timedelta(days=days)
             
-            response = self.client.table('scheduled_events').select(
-                'event_type', 'status'
+            # Получаем события с учетом bot_id через сессии
+            query = self.client.table('session_events').select(
+                'event_type', 'session_id'
             ).gte('created_at', cutoff_date.isoformat())
             
-            events_data = response.execute().data
+            events_response = query.execute()
+            events = events_response.data if events_response.data else []
             
-            stats = {}
-            for event in events_data:
-                event_type = event.get('event_type', 'unknown')
-                status = event.get('status', 'unknown')
+            # Фильтруем события по bot_id через сессии
+            if self.bot_id and events:
+                # Получаем ID сессий этого бота
+                sessions_query = self.client.table('sales_chat_sessions').select('id', 'user_id').eq('bot_id', self.bot_id)
+                sessions_response = sessions_query.execute()
+                
+                # Исключаем сессии тестовых пользователей
+                if sessions_response.data:
+                    # Получаем telegram_id тестовых пользователей
+                    test_users_query = self.client.table('sales_users').select('telegram_id').eq('username', 'test_user')
+                    if self.bot_id:
+                        test_users_query = test_users_query.eq('bot_id', self.bot_id)
+                    
+                    test_users_response = test_users_query.execute()
+                    test_user_ids = {user['telegram_id'] for user in test_users_response.data} if test_users_response.data else set()
+                    
+                    # Фильтруем сессии: только не тестовые
+                    bot_sessions = [s for s in sessions_response.data if s['user_id'] not in test_user_ids]
+                    bot_session_ids = {session['id'] for session in bot_sessions}
+                else:
+                    bot_session_ids = set()
                 
-                key = f"{event_type}_{status}"
-                stats[key] = stats.get(key, 0) + 1
+                # Фильтруем события
+                events = [event for event in events if event['session_id'] in bot_session_ids]
             
-            return stats
+            # Группируем по типам событий
+            event_counts = {}
+            for event in events:
+                event_type = event.get('event_type', 'unknown')
+                event_counts[event_type] = event_counts.get(event_type, 0) + 1
             
-        except Exception as e:
+            return event_counts
+            
+        except APIError as e:
             logger.error(f"Ошибка получения статистики событий: {e}")
             return {}
 
@@ -919,4 +1022,277 @@ class SupabaseClient:
             
         except Exception as e:
             logger.error(f"Ошибка получения последнего события для пользователя {user_id}, тип '{event_type}': {e}")
-            return None
+            return None
+
+    async def get_all_segments(self) -> List[str]:
+        """
+        Получает все уникальные сегменты из таблицы sales_users
+        
+        Returns:
+            List[str]: Список уникальных сегментов
+        """
+        try:
+            # Запрос всех непустых сегментов
+            query = self.client.table('sales_users').select('segments').neq('segments', '')
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+            
+            response = query.execute()
+            
+            # Собираем все уникальные сегменты
+            all_segments = set()
+            for row in response.data:
+                segments_str = row.get('segments', '')
+                if segments_str:
+                    # Разбираем сегменты через запятую
+                    segments = [s.strip() for s in segments_str.split(',') if s.strip()]
+                    all_segments.update(segments)
+            
+            segments_list = sorted(list(all_segments))
+            logger.info(f"Найдено {len(segments_list)} уникальных сегментов")
+            
+            return segments_list
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения сегментов: {e}")
+            return []
+
+    async def get_users_by_segment(self, segment: str = None) -> List[Dict[str, Any]]:
+        """
+        Получает пользователей по сегменту или всех пользователей
+        
+        Args:
+            segment: Название сегмента (если None - возвращает всех)
+            
+        Returns:
+            List[Dict]: Список пользователей с telegram_id
+        """
+        try:
+            query = self.client.table('sales_users').select('telegram_id, segments')
+            
+            if self.bot_id:
+                query = query.eq('bot_id', self.bot_id)
+            
+            response = query.execute()
+            
+            if segment is None:
+                # Все пользователи
+                logger.info(f"Получено {len(response.data)} всех пользователей")
+                return response.data
+            
+            # Фильтруем по сегменту
+            users = []
+            for row in response.data:
+                segments_str = row.get('segments', '')
+                if segments_str:
+                    segments = [s.strip() for s in segments_str.split(',') if s.strip()]
+                    if segment in segments:
+                        users.append(row)
+            
+            logger.info(f"Найдено {len(users)} пользователей с сегментом '{segment}'")
+            return users
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения пользователей по сегменту '{segment}': {e}")
+            return []
+    
+    # =============================================================================
+    # МЕТОДЫ ДЛЯ РАБОТЫ С ФАЙЛАМИ СОБЫТИЙ В SUPABASE STORAGE
+    # =============================================================================
+    
+    async def upload_event_file(self, event_name: str, file_data: bytes, file_name: str) -> Dict[str, str]:
+        """
+        Загружает файл события в Supabase Storage
+        
+        Args:
+            event_name: Название события (используется как папка)
+            file_data: Байты файла
+            file_name: Имя файла
+            
+        Returns:
+            Dict с storage_path
+        """
+        try:
+            bucket_name = 'admin-events'
+            
+            # Формируем путь: admin-events/{event_name}/{file_name}
+            storage_path = f"{event_name}/{file_name}"
+            
+            # Определяем MIME-type
+            import mimetypes
+            content_type, _ = mimetypes.guess_type(file_name)
+            if not content_type:
+                content_type = 'application/octet-stream'
+            
+            # Загружаем в Storage
+            self.client.storage.from_(bucket_name).upload(
+                storage_path,
+                file_data,
+                file_options={"content-type": content_type}
+            )
+            
+            logger.info(f"✅ Файл загружен в Storage: {storage_path}")
+            
+            return {
+                'storage_path': storage_path
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка загрузки файла в Storage: {e}")
+            raise
+    
+    async def download_event_file(self, event_name: str, file_name: str) -> bytes:
+        """
+        Скачивает файл события из Supabase Storage
+        
+        Args:
+            event_name: Название события
+            file_name: Имя файла
+            
+        Returns:
+            bytes: Содержимое файла
+        """
+        try:
+            bucket_name = 'admin-events'
+            storage_path = f"{event_name}/{file_name}"
+            
+            # Скачиваем файл
+            file_data = self.client.storage.from_(bucket_name).download(storage_path)
+            
+            logger.info(f"✅ Файл скачан из Storage: {storage_path}")
+            return file_data
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка скачивания файла из Storage: {e}")
+            raise
+    
+    async def delete_event_files(self, event_name: str):
+        """
+        Удаляет ВСЕ файлы события из Supabase Storage
+        
+        Args:
+            event_name: Название события (папка с файлами)
+        """
+        try:
+            bucket_name = 'admin-events'
+            
+            # Получаем список всех файлов в папке события
+            files_list = self.client.storage.from_(bucket_name).list(event_name)
+            
+            if not files_list:
+                logger.info(f"ℹ️ Нет файлов для удаления в событии '{event_name}'")
+                return
+            
+            # Формируем пути для удаления
+            file_paths = [f"{event_name}/{file['name']}" for file in files_list]
+            
+            # Удаляем файлы
+            self.client.storage.from_(bucket_name).remove(file_paths)
+            
+            logger.info(f"✅ Удалено {len(file_paths)} файлов события '{event_name}' из Storage")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка удаления файлов события из Storage: {e}")
+            # Не прерываем выполнение, только логируем
+
+    async def save_admin_event(
+        self,
+        event_name: str,
+        event_data: Dict[str, Any],
+        scheduled_datetime: datetime
+    ) -> str:
+        """
+        Сохраняет админское событие в таблицу scheduled_events
+        
+        Args:
+            event_name: Название события
+            event_data: Данные события (сегмент, сообщение, файлы)
+            scheduled_datetime: Дата и время отправки (должно быть в UTC с timezone info)
+            
+        Returns:
+            str: ID созданного события
+        """
+        try:
+            import json
+            
+            # Убеждаемся что datetime в правильном формате для PostgreSQL
+            # Если есть timezone info - используем, иначе предполагаем что это UTC
+            if scheduled_datetime.tzinfo is None:
+                logger.warning("⚠️ scheduled_datetime без timezone info, предполагаем UTC")
+                from datetime import timezone
+                scheduled_datetime = scheduled_datetime.replace(tzinfo=timezone.utc)
+            
+            event_record = {
+                'event_type': event_name,
+                'event_category': 'admin_event',
+                'user_id': None,  # Для всех пользователей
+                'event_data': json.dumps(event_data, ensure_ascii=False),
+                'scheduled_at': scheduled_datetime.isoformat(),
+                'status': 'pending'
+            }
+            
+            response = self.client.table('scheduled_events').insert(event_record).execute()
+            event_id = response.data[0]['id']
+            
+            logger.info(f"💾 Админское событие '{event_name}' сохранено в БД: {event_id} на {scheduled_datetime.isoformat()}")
+            return event_id
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка сохранения админского события: {e}")
+            raise
+
+    async def get_admin_events(self, status: str = None) -> List[Dict[str, Any]]:
+        """
+        Получает админские события
+        
+        Args:
+            status: Фильтр по статусу (pending, completed, cancelled)
+            
+        Returns:
+            List[Dict]: Список админских событий
+        """
+        try:
+            query = self.client.table('scheduled_events').select(
+                '*'
+            ).eq('event_category', 'admin_event')
+            
+            if status:
+                query = query.eq('status', status)
+            
+            response = query.order('scheduled_at', desc=False).execute()
+            
+            logger.info(f"Найдено {len(response.data)} админских событий")
+            return response.data
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения админских событий: {e}")
+            return []
+    
+    async def check_event_name_exists(self, event_name: str) -> bool:
+        """
+        Проверяет существует ли активное событие с таким названием
+        
+        Args:
+            event_name: Название события для проверки
+            
+        Returns:
+            bool: True если активное событие с таким именем существует
+        """
+        try:
+            response = self.client.table('scheduled_events').select(
+                'id', 'event_type', 'status'
+            ).eq('event_category', 'admin_event').eq(
+                'event_type', event_name
+            ).eq('status', 'pending').execute()
+            
+            exists = len(response.data) > 0
+            
+            if exists:
+                logger.info(f"⚠️ Найдено активное событие с названием '{event_name}'")
+            
+            return exists
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки названия события: {e}")
+            return False

smart_bot_factory/utm_link_generator.py

@@ -24,20 +24,24 @@ def get_user_input():
     utm_content = input("utm_content (контент): ").strip()
     utm_term = input("utm_term (ключевое слово): ").strip()
     
+    print("\n🎯 Сегментация (нажмите Enter для пропуска):")
+    segment = input("seg (сегмент): ").strip()
+    
     return {
         'bot_username': bot_username,
         'utm_source': utm_source,
         'utm_medium': utm_medium,
         'utm_campaign': utm_campaign,
         'utm_content': utm_content,
-        'utm_term': utm_term
+        'utm_term': utm_term,
+        'segment': segment
     }
 
 def create_utm_string(utm_data):
-    """Создает строку UTM параметров в формате source-vk_campaign-summer2025"""
+    """Создает строку UTM параметров в формате source-vk_campaign-summer2025_seg-premium"""
     utm_parts = []
     
-    # Маппинг полей базы данных на новый формат (без utm, в нижнем регистре)
+    # Маппинг полей базы данных на формат без префикса utm
     field_mapping = {
         'utm_source': 'source',
         'utm_medium': 'medium', 
@@ -51,6 +55,11 @@ def create_utm_string(utm_data):
         if value:
             utm_parts.append(f"{utm_field}-{value}")
     
+    # Добавляем сегмент, если указан
+    segment = utm_data.get('segment')
+    if segment:
+        utm_parts.append(f"seg-{segment}")
+    
     return "_".join(utm_parts)
 
 def generate_telegram_link(bot_username, utm_string):
@@ -104,3 +113,4 @@ def main():
 
 if __name__ == "__main__":
     main()
+

{smart_bot_factory-0.3.2.dist-info → smart_bot_factory-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-bot-factory
-Version: 0.3.2
+Version: 0.3.3
 Summary: Библиотека для создания умных чат-ботов
 Author-email: Kopatych <eserov73@gmail.com>
 License: MIT
@@ -25,6 +25,7 @@ Requires-Dist: aiogram>=3.4.1
 Requires-Dist: click>=8.0.0
 Requires-Dist: openai>=1.12.0
 Requires-Dist: project-root-finder>=1.9
+Requires-Dist: python-dateutil>=2.9.0.post0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: pytz>=2023.3
 Requires-Dist: pyyaml>=6.0.2

{smart_bot_factory-0.3.2.dist-info → smart_bot_factory-0.3.3.dist-info}/RECORD

@@ -1,15 +1,21 @@
 smart_bot_factory/__init__.py,sha256=W5k9awLVi0R_N3fSul7VNkKRdSfExZjNb_M2yNzepg8,102
-smart_bot_factory/cli.py,sha256=ws0tYUYDFXCq1e1PyE4Z5P3GQkDjx7xM4gvyywLJKKE,33225
+smart_bot_factory/cli.py,sha256=eQ2fv0uc87nrm1b-lRRw0Tz52NquCcwkk2it__beNKU,33223
 smart_bot_factory/config.py,sha256=kB3G2hGMrrCSOAvlrddf8x43bgfgEaQqOCKOeELAzfM,11640
 smart_bot_factory/setup_checker.py,sha256=fqRzyptyMzcb2I0boUaj0rWLdarqaN6ViX6suwTEeWc,20123
-smart_bot_factory/utm_link_generator.py,sha256=jw7c84Y_ZvLpV4jaBWw0GK3-lCUKIIa8sZ8YNxoWIlc,4166
-smart_bot_factory/admin/__init__.py,sha256=aA8VMXkFn7TiWAMeHzkXCPFGEPxJvL2ECdFASSr7jtU,397
-smart_bot_factory/admin/admin_logic.py,sha256=guNhwm_LmliMACN_KX7z7emNwyhkN7UmAhFda7nsVMk,20736
+smart_bot_factory/utm_link_generator.py,sha256=wYPdYYK555YfOP22eJXAcEv_D66_t50Dhg0-wkLVzVk,4502
+smart_bot_factory/admin/__init__.py,sha256=vdsMTpt_LiXkY-awFu_X9e2Zt7CV50PwmsWkFbk6whk,488
+smart_bot_factory/admin/admin_events.py,sha256=yU52QWc1GC-E-WAA_A3HAXpY3zMG96eGq97FtHC5ZB0,34804
+smart_bot_factory/admin/admin_logic.py,sha256=zyaklL-s0LihPGHVbguOB9F0NMaggHAyQGukco_kTtA,22831
 smart_bot_factory/admin/admin_manager.py,sha256=xlyG9mIjPmtUhS4E9lp36T7o5Kfp5PZpJ-r1QjnSn5g,6394
 smart_bot_factory/admin/admin_migration.sql,sha256=kleMPJBSe2Z7ZZz7rNyOX_yoh4GZivGesqAX90U5PGs,5667
 smart_bot_factory/admin/admin_tester.py,sha256=PGFpf7fmD5Wxea31xR2ZM_A_QpvrB73gsbxvUrHQBkg,6463
 smart_bot_factory/admin/timeout_checker.py,sha256=TzA2FGrxwE8fuhKerGnGrt4qYMEZdIR8x3SQAnIW5YQ,24490
-smart_bot_factory/analytics/analytics_manager.py,sha256=JQgKGkPPt07vI6KYWpa7OAimgl5SyF5cbiM89N4LKIQ,16298
+smart_bot_factory/aiogram_calendar/__init__.py,sha256=_IzB_HJIZuMs__7xBBsYVG20GbRNFw2VowvhOEyiGGc,349
+smart_bot_factory/aiogram_calendar/common.py,sha256=Ik-ler6Hid11SHpphqfFs5FjvGhj8Ajz0ds-MWMjPoo,2659
+smart_bot_factory/aiogram_calendar/dialog_calendar.py,sha256=AVuIWPp4D8ri7N7aSNqfZ_SicbfYGvQWeJqSmakGkuE,8289
+smart_bot_factory/aiogram_calendar/schemas.py,sha256=y2jnnFuqOqLZ7PwY6WQrzmRgCE6rwFYUGTFYaQnCouM,2524
+smart_bot_factory/aiogram_calendar/simple_calendar.py,sha256=XmCFjrDNJZ9LNEGkbY1vqRbU9t2EgIk69tGg5xy2sfE,7859
+smart_bot_factory/analytics/analytics_manager.py,sha256=y1DI_TnAdSX5NG_mwqHD1emne4opfsyo50D_tebi_UA,17967
 smart_bot_factory/configs/growthmed-october-24/prompts/1sales_context.txt,sha256=uJ4WviYIr9xJaFdu-APrrmBgIWVwdJymcN04upIviLY,1614
 smart_bot_factory/configs/growthmed-october-24/prompts/2product_info.txt,sha256=tWP9gdn58vu9BhYpDx1lGuPNT24j5p1XPiCSD-CdXiU,24191
 smart_bot_factory/configs/growthmed-october-24/prompts/3objection_handling.txt,sha256=zwUGKp3mp1dAQUPjLQsCsczwRJJOqn9GGvVzVBCpvfY,6985
@@ -24,32 +30,30 @@ smart_bot_factory/configs/growthmed-october-24/tests/realistic_scenarios.yaml,sh
 smart_bot_factory/configs/growthmed-october-24/tests/scenario_examples.yaml,sha256=bzDulOU4a2LyWlcHzlQU8GYhOky2WTfyizGfjX4ioMY,2436
 smart_bot_factory/configs/growthmed-october-24/welcome_file/welcome_file_msg.txt,sha256=Db21Mm0r8SBWFdX9EeIF2FZtLQ2cvuwVlSRJd2KEYCg,922
 smart_bot_factory/configs/growthmed-october-24/welcome_file/Чек лист по 152ФЗ и 323ФЗ для медицины.pdf,sha256=BiAiQHNnQXJPMsks9AeL6s0beEjRFkRMJLMlAn4WorA,5284954
-smart_bot_factory/core/bot_utils.py,sha256=cWCasEG_4BTTp35d3P3BIOjpn9NXOCd1b6cKhNNpNb0,44670
+smart_bot_factory/core/bot_utils.py,sha256=Be334BPspBgHNO9OpEiPlrCc0Gmy7_8sox5WpV8XHic,45174
 smart_bot_factory/core/conversation_manager.py,sha256=eoHL7MCEz68DRvTVwRwZgf2PWwGv4T6J9D-I-thETi8,28289
-smart_bot_factory/core/decorators.py,sha256=maxoj2rdEGZmqgK6jybaTOcTXx_b32t5fWkNeJ2JdOs,83324
+smart_bot_factory/core/decorators.py,sha256=gJWaJVyCoBSsy4EsaJTv4OPVK-Efv1pQLm54Odgu4Lk,93678
 smart_bot_factory/core/message_sender.py,sha256=J4b6n8nXVjqf-qzL6URRSvc-FVnQfShwujVSM6qv26w,32232
 smart_bot_factory/core/router.py,sha256=03fbysaj0LR96p4-8iiml8dTmEHCkR-AaTposSv8q8o,11898
 smart_bot_factory/core/router_manager.py,sha256=dUwesog-oHk1U2EDdS8p0e4MTSkwtx5_qXn6nrJ9l9I,9700
-smart_bot_factory/core/states.py,sha256=AOc19_yAsDW_8md-2oiowjBhuW3bwcsmMxszCXWZZTQ,355
+smart_bot_factory/core/states.py,sha256=L8qp1UmYFuxTN5U9tY076rDuKgxtFbpSGqBpva2eWbo,895
 smart_bot_factory/creation/__init__.py,sha256=IgDk8GDS3pg7Pw_Et41J33ZmeZIU5dRwQdTmYKXfJfE,128
-smart_bot_factory/creation/bot_builder.py,sha256=KQmMmiL9OuGZAR3rYxMNk-2opMUR5NPRy9Sf9iVNCoU,39463
+smart_bot_factory/creation/bot_builder.py,sha256=yGRmOPD7qCMbhcBiltHWISoKxWx8eqjDSnZXpwhqnUs,43115
 smart_bot_factory/creation/bot_testing.py,sha256=JDWXyJfZmbgo-DLdAPk8Sd9FiehtHHa4sLD17lBrTOc,55669
 smart_bot_factory/event/__init__.py,sha256=hPL449RULIOB-OXv1ZbGNiHctAYaOMUqhSWGPrDHYBM,212
-smart_bot_factory/handlers/handlers.py,sha256=urTUYSqK9zDxomFbC056gN5T4o7Gz9gN0bm84DPzvVc,60390
+smart_bot_factory/handlers/handlers.py,sha256=jMKD04v81BbCNLl_00rAM_rgPDH1mMdHZlLI8ZhXpc8,60438
 smart_bot_factory/integrations/openai_client.py,sha256=fwaJpwojFdLBWChcFWpFGOHK9upG-nCIwDochkCRRlY,24291
-smart_bot_factory/integrations/supabase_client.py,sha256=AfALLZdDYeMWHLJw6POTGiBd-sH3i03oT6tT7m9C28I,44644
+smart_bot_factory/integrations/supabase_client.py,sha256=XznvAXqcMBqHw2_-t91Exyomru-mLP6-BlYuEeoUJSY,63082
 smart_bot_factory/message/__init__.py,sha256=-ehDZweUc3uKgmLLxFVsD-KWrDtnHpHms7pCrDelWo0,1950
 smart_bot_factory/router/__init__.py,sha256=5gEbpG3eylOyow5NmidzGUy0K-AZq7RhYLVu9OaUT6c,270
 smart_bot_factory/supabase/__init__.py,sha256=XmZP6yM9ffERM5ddAWyJnrNzEhCYtMu3AcjVCi1rOf8,179
 smart_bot_factory/supabase/client.py,sha256=lWIzfOgoSvU7xPhYLoJtM5GnbWdoWsvHcRFC22sFBMU,25637
-smart_bot_factory/table/database_structure.sql,sha256=26gFtMC2jdQGQF7Zb_F4Br56rMd4hUDTk9FkNZYneLo,2789
-smart_bot_factory/table/schema.sql,sha256=-6kOmA9QnSkUtmGI2iQRbTvbdiqOhEOQcuz1lJn79mU,28059
 smart_bot_factory/utils/__init__.py,sha256=UhsJXEHfrIK8h1AHsroHSwAriijk-LvnqLyvgzi2VYs,273
 smart_bot_factory/utils/debug_routing.py,sha256=BOoDhKBg7UXe5uHQxRk3TSfPfLPOFqt0N7lAo6kjCOo,4719
 smart_bot_factory/utils/prompt_loader.py,sha256=JSn7CsWnToSbHYtURdeuZn7ectyDqQGrPGHN2ixIGkw,19930
 smart_bot_factory/utils/user_prompt_loader.py,sha256=dk6P0X_3UcNqxjRtuIvb0LcPrp03zIIsstZwdmeCPaE,2519
-smart_bot_factory-0.3.2.dist-info/METADATA,sha256=alPg424Y9-vgxD2LUovu3EJJNMLlxuTqEPXukWJBw0c,31905
-smart_bot_factory-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smart_bot_factory-0.3.2.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
-smart_bot_factory-0.3.2.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
-smart_bot_factory-0.3.2.dist-info/RECORD,,
+smart_bot_factory-0.3.3.dist-info/METADATA,sha256=kyf-bct-Sf1zvA6PwlUtTOGJ17kV7q8FuqtrjvNvXRM,31949
+smart_bot_factory-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smart_bot_factory-0.3.3.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
+smart_bot_factory-0.3.3.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
+smart_bot_factory-0.3.3.dist-info/RECORD,,