Fix: Update to RoSBERTa model (1024 dims), remove half precision, increase timeout

add_admin_user.py

@@ -0,0 +1,188 @@
+"""
+Скрипт для добавления тестового пользователя-администратора в БД.
+
+Подключается к PostgreSQL на Render и создает пользователя с ролью ADMIN.
+"""
+
+import psycopg2
+import bcrypt
+from uuid import uuid4
+
+# Параметры подключения к БД на Render
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+# Данные администратора
+ADMIN_USER = {
+    'user_id': str(uuid4()),
+    'email': 'admin@leadexchange.com',
+    'password': 'admin123',  # Будет захеширован
+    'first_name': 'Админ',
+    'last_name': 'Администраторов',
+    'phone': '+79999999999',
+    'agency_name': 'Lead Exchange Administration',
+    'avatar_url': 'https://cdn.pixabay.com/photo/2015/10/05/22/37/blank-profile-picture-973460_1280.png',
+    'role': 'ADMIN'
+}
+
+
+def hash_password(password: str) -> str:
+    """Хеширование пароля с помощью bcrypt."""
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
+    return hashed.decode('utf-8')
+
+
+def create_admin_user():
+    """Создание пользователя-администратора в БД."""
+    try:
+        # Подключение к БД
+        print(f"Подключение к базе данных {DB_CONFIG['database']}...")
+        conn = psycopg2.connect(**DB_CONFIG)
+        cursor = conn.cursor()
+
+        # Проверяем, существует ли таблица users
+        cursor.execute("""
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_name = 'users'
+            );
+        """)
+        table_exists = cursor.fetchone()[0]
+
+        if not table_exists:
+            print("⚠️  Таблица 'users' не существует. Создаем...")
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id       UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+                    email         TEXT        NOT NULL UNIQUE,
+                    password_hash TEXT        NOT NULL,
+                    first_name    TEXT        NOT NULL,
+                    last_name     TEXT        NOT NULL,
+                    phone         TEXT UNIQUE,
+                    agency_name   TEXT,
+                    avatar_url    TEXT,
+                    role          TEXT        NOT NULL,
+                    created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW()
+                );
+            """)
+            conn.commit()
+            print("✅ Таблица 'users' создана")
+
+        # Проверяем, существует ли уже пользователь с таким email
+        cursor.execute("SELECT email FROM users WHERE email = %s", (ADMIN_USER['email'],))
+        existing_user = cursor.fetchone()
+
+        if existing_user:
+            print(f"⚠️  Пользователь с email {ADMIN_USER['email']} уже существует")
+
+            # Спрашиваем, обновить ли пароль
+            update = input("Обновить пароль? (y/n): ").lower().strip()
+            if update == 'y':
+                password_hash = hash_password(ADMIN_USER['password'])
+                cursor.execute(
+                    "UPDATE users SET password_hash = %s WHERE email = %s",
+                    (password_hash, ADMIN_USER['email'])
+                )
+                conn.commit()
+                print("✅ Пароль обновлен")
+            else:
+                print("❌ Операция отменена")
+            return
+
+        # Хешируем пароль
+        print("Хеширование пароля...")
+        password_hash = hash_password(ADMIN_USER['password'])
+
+        # Вставляем пользователя
+        print(f"Создание администратора {ADMIN_USER['email']}...")
+        cursor.execute("""
+            INSERT INTO users (
+                user_id, email, password_hash, first_name, last_name,
+                phone, agency_name, avatar_url, role
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+        """, (
+            ADMIN_USER['user_id'],
+            ADMIN_USER['email'],
+            password_hash,
+            ADMIN_USER['first_name'],
+            ADMIN_USER['last_name'],
+            ADMIN_USER['phone'],
+            ADMIN_USER['agency_name'],
+            ADMIN_USER['avatar_url'],
+            ADMIN_USER['role']
+        ))
+
+        conn.commit()
+
+        print("\n" + "="*60)
+        print("✅ Администратор успешно создан!")
+        print("="*60)
+        print(f"ID:       {ADMIN_USER['user_id']}")
+        print(f"Email:    {ADMIN_USER['email']}")
+        print(f"Пароль:   {ADMIN_USER['password']}")
+        print(f"Роль:     {ADMIN_USER['role']}")
+        print(f"Имя:      {ADMIN_USER['first_name']} {ADMIN_USER['last_name']}")
+        print(f"Телефон:  {ADMIN_USER['phone']}")
+        print("="*60)
+
+        cursor.close()
+        conn.close()
+
+    except psycopg2.Error as e:
+        print(f"❌ Ошибка PostgreSQL: {e}")
+        raise
+    except Exception as e:
+        print(f"❌ Ошибка: {e}")
+        raise
+
+
+def verify_admin_user():
+    """Проверка, что администратор успешно создан."""
+    try:
+        conn = psycopg2.connect(**DB_CONFIG)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            SELECT user_id, email, first_name, last_name, role, created_at
+            FROM users
+            WHERE email = %s
+        """, (ADMIN_USER['email'],))
+
+        user = cursor.fetchone()
+
+        if user:
+            print("\n📋 Информация о пользователе в БД:")
+            print(f"   ID:         {user[0]}")
+            print(f"   Email:      {user[1]}")
+            print(f"   Имя:        {user[2]} {user[3]}")
+            print(f"   Роль:       {user[4]}")
+            print(f"   Создан:     {user[5]}")
+        else:
+            print("❌ Пользователь не найден в БД")
+
+        cursor.close()
+        conn.close()
+
+    except Exception as e:
+        print(f"❌ Ошибка при проверке: {e}")
+
+
+if __name__ == "__main__":
+    print("🚀 Скрипт создания администратора Lead Exchange")
+    print("-" * 60)
+
+    try:
+        create_admin_user()
+        verify_admin_user()
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Операция прервана пользователем")
+    except Exception as e:
+        print(f"\n❌ Критическая ошибка: {e}")
+        exit(1)
+

add_properties.py

@@ -0,0 +1,283 @@
+"""
+Скрипт для добавления объектов недвижимости из pars_samolet.sql в базу данных Render
+"""
+import psycopg2
+import re
+import sqlite3
+import uuid
+import sys
+from datetime import datetime
+
+# Данные подключения к БД на Render
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+# ID администратора (который мы создали ранее)
+ADMIN_USER_ID = None  # Будет получен из БД
+
+def get_admin_user_id(conn):
+    """Получить ID администратора из БД"""
+    cursor = conn.cursor()
+
+    # Получаем всех администраторов
+    cursor.execute("""
+        SELECT user_id, email, first_name, last_name
+        FROM users
+        WHERE role = 'ADMIN'
+        ORDER BY created_at DESC
+    """)
+    admins = cursor.fetchall()
+
+    if not admins:
+        raise Exception("Admin user not found in database. Please run add_admin_user.py first.")
+
+    if len(admins) == 1:
+        admin_id, email, first_name, last_name = admins[0]
+        print(f"  Found admin: {email} ({first_name} {last_name})")
+        return str(admin_id)
+
+    # Если несколько админов, показываем их и выбираем последнего созданного (самый новый)
+    print(f"  Found {len(admins)} admin users:")
+    for admin_id, email, first_name, last_name in admins:
+        print(f"    - {email} ({first_name} {last_name}) - ID: {admin_id}")
+
+    # Используем самого нового администратора (первый в списке, т.к. ORDER BY created_at DESC)
+    selected_admin = admins[0]
+    print(f"  ✅ Using: {selected_admin[1]}")
+    return str(selected_admin[0])
+
+def parse_sql_file():
+    """Парсинг SQL файла с объектами недвижимости"""
+    print("Reading pars_samolet.sql...")
+
+    with open('pars_samolet.sql', 'r', encoding='utf-8') as f:
+        sql_content = f.read()
+
+    # Извлекаем CREATE TABLE
+    create_match = re.search(r'CREATE TABLE[^;]+;', sql_content, re.DOTALL)
+    if not create_match:
+        raise ValueError("CREATE TABLE not found")
+    create_stmt = create_match.group(0)
+
+    # Извлекаем все INSERT
+    insert_pattern = r'INSERT INTO mytable\([^)]+\) VALUES\s*\([^;]+\);'
+    inserts = re.findall(insert_pattern, sql_content, re.DOTALL)
+
+    print(f"Found {len(inserts)} INSERT statements")
+
+    # Создаем временную базу для парсинга
+    conn = sqlite3.connect(':memory:')
+    cursor = conn.cursor()
+    cursor.execute(create_stmt)
+
+    # Выполняем INSERT
+    successful = 0
+    for i, insert in enumerate(inserts):
+        try:
+            cursor.execute(insert)
+            successful += 1
+        except sqlite3.Error as e:
+            print(f"Warning: Could not parse INSERT #{i+1}: {e}")
+            continue
+
+    print(f"Successfully parsed {successful}/{len(inserts)} records")
+
+    # Получаем данные
+    cursor.execute('SELECT * FROM mytable')
+    rows = cursor.fetchall()
+
+    # Получаем имена колонок
+    cursor.execute("PRAGMA table_info(mytable)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    # Создаем список словарей
+    objects = [dict(zip(columns, row)) for row in rows]
+    conn.close()
+
+    return objects
+
+def map_property_type(old_type):
+    """Маппинг типов недвижимости"""
+    mapping = {
+        'Квартира': 'APARTMENT',
+        'Дом': 'HOUSE',
+        'Коммерческая': 'COMMERCIAL',
+        'Участок': 'LAND'
+    }
+    return mapping.get(old_type, 'APARTMENT')
+
+def map_status(old_status):
+    """Маппинг статусов"""
+    mapping = {
+        'Доступно': 'PUBLISHED',
+        'Продано': 'SOLD',
+        'Архив': 'ARCHIVED'
+    }
+    return mapping.get(old_status, 'PUBLISHED')
+
+def insert_properties(objects, owner_user_id, auto_confirm=False):
+    """Вставка объектов недвижимости в БД"""
+    print(f"\nConnecting to database at {DB_CONFIG['host']}...")
+
+    try:
+        conn = psycopg2.connect(**DB_CONFIG)
+        cursor = conn.cursor()
+
+        print("Connected successfully!")
+
+        # Проверяем, есть ли уже данные
+        cursor.execute("SELECT COUNT(*) FROM properties")
+        existing_count = cursor.fetchone()[0]
+        print(f"Current properties in database: {existing_count}")
+
+        if existing_count > 0:
+            if auto_confirm:
+                print(f"\nAuto-confirm enabled: Deleting {existing_count} existing properties...")
+                cursor.execute("DELETE FROM properties")
+                conn.commit()
+                print("Deleted existing properties")
+            else:
+                try:
+                    response = input(f"\nDatabase already has {existing_count} properties. Delete them? (yes/y/no/n): ")
+                    if response.lower() in ['yes', 'y']:
+                        cursor.execute("DELETE FROM properties")
+                        conn.commit()
+                        print("Deleted existing properties")
+                except EOFError:
+                    print("\n⚠️  Input interrupted. Keeping existing properties.")
+                    print("Run with --yes flag to auto-confirm or run interactively.")
+
+        # Вставляем объекты
+        inserted = 0
+        failed = 0
+
+        insert_query = """
+        INSERT INTO properties (
+            property_id, title, description, address, property_type,
+            area, price, rooms, status, owner_user_id, created_user_id,
+            created_at, updated_at
+        ) VALUES (
+            %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+        )
+        """
+
+        print(f"\nInserting {len(objects)} properties...")
+
+        for i, obj in enumerate(objects):
+            try:
+                # Подготавливаем данные
+                property_id = obj.get('property_id', str(uuid.uuid4()))
+                title = obj.get('title', '')[:255]  # Ограничиваем длину
+                description = obj.get('description', '')
+                address = obj.get('address', '')
+                property_type = map_property_type(obj.get('property_type', 'Квартира'))
+                area = float(obj['area']) if obj.get('area') else None
+                price = int(obj['price']) if obj.get('price') else None
+                rooms = int(obj['rooms']) if obj.get('rooms') else None
+                status = map_status(obj.get('status', 'Доступно'))
+
+                # Даты
+                created_at = obj.get('created_at', datetime.now().isoformat())
+                updated_at = obj.get('updated_at', datetime.now().isoformat())
+
+                cursor.execute(insert_query, (
+                    property_id, title, description, address, property_type,
+                    area, price, rooms, status, owner_user_id, owner_user_id,
+                    created_at, updated_at
+                ))
+
+                inserted += 1
+
+                if (i + 1) % 50 == 0:
+                    print(f"  Inserted {i + 1}/{len(objects)}...")
+
+            except Exception as e:
+                failed += 1
+                print(f"  Failed to insert property {obj.get('property_id', 'unknown')}: {e}")
+                continue
+
+        # Коммитим изменения
+        conn.commit()
+
+        print(f"\n✅ Successfully inserted {inserted} properties")
+        if failed > 0:
+            print(f"⚠️  Failed to insert {failed} properties")
+
+        # Проверяем финальное количество
+        cursor.execute("SELECT COUNT(*) FROM properties")
+        final_count = cursor.fetchone()[0]
+        print(f"\nTotal properties in database: {final_count}")
+
+        cursor.close()
+        conn.close()
+
+    except psycopg2.Error as e:
+        print(f"❌ Database error: {e}")
+        raise
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        raise
+
+def main():
+    print("=" * 60)
+    print("Adding Properties to Database")
+    print("=" * 60)
+
+    # Проверяем параметры командной строки
+    auto_confirm = '--yes' in sys.argv or '-y' in sys.argv
+
+    if auto_confirm:
+        print("🤖 Auto-confirm mode enabled")
+
+    # Парсим SQL файл
+    objects = parse_sql_file()
+
+    if not objects:
+        print("No objects found in pars_samolet.sql")
+        return
+
+    print(f"\nParsed {len(objects)} properties from file")
+    print(f"Sample property: {objects[0].get('title', 'N/A')}")
+
+    # Подключаемся к БД и получаем ID администратора
+    print("\nGetting admin user ID...")
+    try:
+        conn = psycopg2.connect(**DB_CONFIG)
+        admin_id = get_admin_user_id(conn)
+        conn.close()
+        print(f"Admin user ID: {admin_id}")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return
+
+    # Подтверждение
+    if not auto_confirm:
+        print(f"\nReady to insert {len(objects)} properties into database")
+        print(f"Database: {DB_CONFIG['host']}/{DB_CONFIG['database']}")
+        try:
+            response = input("\nProceed? (yes/y/no/n): ")
+            if response.lower() not in ['yes', 'y']:
+                print("Cancelled by user")
+                return
+        except EOFError:
+            print("\n❌ Error: EOF when reading input")
+            print("Run with --yes flag to auto-confirm: python add_properties.py --yes")
+            return
+    else:
+        print(f"\n✅ Auto-confirming insertion of {len(objects)} properties")
+
+    # Вставляем объекты
+    insert_properties(objects, admin_id, auto_confirm)
+
+    print("\n" + "=" * 60)
+    print("✅ Done!")
+    print("=" * 60)
+
+if __name__ == '__main__':
+    main()
+

check_embeddings_table.py

@@ -0,0 +1,112 @@
+"""
+Проверка наличия таблицы для эмбеддингов в БД
+"""
+import psycopg2
+
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+try:
+    conn = psycopg2.connect(**DB_CONFIG)
+    cursor = conn.cursor()
+
+    print("=" * 70)
+    print("CHECKING EMBEDDINGS STORAGE")
+    print("=" * 70)
+
+    # Проверяем все таблицы
+    cursor.execute("""
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+        ORDER BY table_name
+    """)
+
+    tables = [row[0] for row in cursor.fetchall()]
+    print(f"\n📋 All tables in database:")
+    for table in tables:
+        print(f"  - {table}")
+
+    # Проверяем наличие pgvector extension
+    cursor.execute("""
+        SELECT * FROM pg_extension WHERE extname = 'vector'
+    """)
+    has_pgvector = cursor.fetchone() is not None
+    print(f"\n🔌 pgvector extension: {'✅ Installed' if has_pgvector else '❌ Not installed'}")
+
+    # Проверяем структуру properties
+    cursor.execute("""
+        SELECT column_name, data_type, character_maximum_length
+        FROM information_schema.columns
+        WHERE table_name = 'properties'
+        ORDER BY ordinal_position
+    """)
+
+    print(f"\n🏠 Properties table structure:")
+    has_embedding_column = False
+    for col_name, data_type, max_length in cursor.fetchall():
+        if 'embedding' in col_name.lower():
+            has_embedding_column = True
+            print(f"  ✅ {col_name}: {data_type}")
+        else:
+            print(f"  - {col_name}: {data_type}")
+
+    if not has_embedding_column:
+        print(f"\n⚠️  No embedding column found in properties table")
+
+    # Проверяем наличие отдельной таблицы для эмбеддингов
+    embedding_tables = [t for t in tables if 'embedding' in t.lower() or 'vector' in t.lower()]
+
+    if embedding_tables:
+        print(f"\n📊 Found embedding-related tables:")
+        for table in embedding_tables:
+            print(f"  - {table}")
+            cursor.execute(f"""
+                SELECT column_name, data_type
+                FROM information_schema.columns
+                WHERE table_name = '{table}'
+                ORDER BY ordinal_position
+            """)
+            for col_name, data_type in cursor.fetchall():
+                print(f"    - {col_name}: {data_type}")
+    else:
+        print(f"\n⚠️  No separate table for embeddings found")
+
+    print("\n" + "=" * 70)
+    print("RECOMMENDATION")
+    print("=" * 70)
+
+    if has_pgvector and has_embedding_column:
+        print("✅ Ready to store embeddings in properties table")
+        print("   Use: ALTER TABLE properties ADD COLUMN embedding vector(768)")
+    elif has_pgvector and embedding_tables:
+        print("✅ Can store embeddings in separate table")
+    else:
+        print("⚠️  Need to create storage for embeddings:")
+        print("")
+        print("Option 1: Add column to properties (recommended)")
+        print("  ALTER TABLE properties ADD COLUMN embedding vector(768);")
+        print("  CREATE INDEX ON properties USING ivfflat (embedding vector_cosine_ops);")
+        print("")
+        print("Option 2: Create separate table")
+        print("  CREATE TABLE property_embeddings (")
+        print("    property_id UUID PRIMARY KEY REFERENCES properties(property_id),")
+        print("    embedding vector(768),")
+        print("    created_at TIMESTAMPTZ DEFAULT NOW()")
+        print("  );")
+        print("")
+        print("⚠️  First install pgvector: CREATE EXTENSION vector;")
+
+    cursor.close()
+    conn.close()
+
+except Exception as e:
+    print(f"❌ Error: {e}")
+    import traceback
+    traceback.print_exc()
+

check_service_status.py

@@ -0,0 +1,79 @@
+"""
+Проверка статуса сервиса на HuggingFace Spaces
+"""
+import requests
+import time
+
+HF_SERVICE_URL = "https://calcifer0323-matching.hf.space"
+
+print("=" * 70)
+print("CHECKING HUGGINGFACE SPACES SERVICE STATUS")
+print("=" * 70)
+
+endpoints = [
+    "/health",
+    "/docs",
+    "/"
+]
+
+for endpoint in endpoints:
+    try:
+        print(f"\n🔍 Checking {endpoint}...")
+        response = requests.get(
+            f"{HF_SERVICE_URL}{endpoint}",
+            timeout=10
+        )
+
+        print(f"  Status: {response.status_code}")
+
+        if response.status_code == 200:
+            print(f"  ✅ Endpoint working")
+            if endpoint == "/health":
+                data = response.json()
+                print(f"     Status: {data.get('status', 'unknown')}")
+                print(f"     Model: {data.get('model', 'unknown')}")
+                print(f"     Dimensions: {data.get('dimensions', 'unknown')}")
+        else:
+            print(f"  ⚠️  Endpoint returned {response.status_code}")
+            print(f"     Response: {response.text[:200]}")
+
+    except requests.exceptions.Timeout:
+        print(f"  ❌ Timeout")
+    except requests.exceptions.ConnectionError:
+        print(f"  ❌ Connection error")
+    except Exception as e:
+        print(f"  ❌ Error: {e}")
+
+print("\n" + "=" * 70)
+print("TESTING /embed ENDPOINT")
+print("=" * 70)
+
+test_text = "3-комнатная квартира в центре Москвы"
+payload = {"text": test_text}
+
+try:
+    print(f"\n📝 Test text: {test_text}")
+    print(f"📤 Sending to /embed...")
+
+    response = requests.post(
+        f"{HF_SERVICE_URL}/embed",
+        json=payload,
+        timeout=30
+    )
+
+    print(f"  Status: {response.status_code}")
+
+    if response.status_code == 200:
+        data = response.json()
+        print(f"  ✅ Success!")
+        print(f"     Embedding dimensions: {data.get('dimensions', 'unknown')}")
+        print(f"     Model: {data.get('model', 'unknown')}")
+    else:
+        print(f"  ❌ Error")
+        print(f"     Response: {response.text[:500]}")
+
+except Exception as e:
+    print(f"  ❌ Failed: {e}")
+
+print("\n" + "=" * 70)
+

cleanup_and_verify.py

@@ -0,0 +1,71 @@
+"""
+Скрипт для полной очистки и повторной вставки объектов с правильным admin user
+"""
+import psycopg2
+
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+print("=" * 70)
+print("CLEANUP AND VERIFICATION")
+print("=" * 70)
+
+try:
+    conn = psycopg2.connect(**DB_CONFIG)
+    cursor = conn.cursor()
+
+    # Показываем текущее состояние
+    cursor.execute("SELECT COUNT(*) FROM properties")
+    current_count = cursor.fetchone()[0]
+    print(f"\n📊 Current properties count: {current_count}")
+
+    # Показываем всех админов
+    cursor.execute("""
+        SELECT user_id, email, first_name, last_name, created_at
+        FROM users
+        WHERE role = 'ADMIN'
+        ORDER BY created_at DESC
+    """)
+    admins = cursor.fetchall()
+    print(f"\n👥 Admin users in database:")
+    for user_id, email, first_name, last_name, created in admins:
+        print(f"  - {email}")
+        print(f"    Name: {first_name} {last_name}")
+        print(f"    ID: {user_id}")
+        print(f"    Created: {created}")
+
+        # Проверяем сколько properties у этого админа
+        cursor.execute("SELECT COUNT(*) FROM properties WHERE owner_user_id = %s", (user_id,))
+        prop_count = cursor.fetchone()[0]
+        print(f"    Properties: {prop_count}")
+        print()
+
+    # Удаляем все properties
+    print("🗑️  Deleting all properties...")
+    cursor.execute("DELETE FROM properties")
+    conn.commit()
+    print("✅ All properties deleted")
+
+    # Проверяем
+    cursor.execute("SELECT COUNT(*) FROM properties")
+    final_count = cursor.fetchone()[0]
+    print(f"📊 Properties after cleanup: {final_count}")
+
+    print("\n" + "=" * 70)
+    print("✅ Ready for fresh insert!")
+    print("Run: python add_properties.py --yes")
+    print("=" * 70)
+
+    cursor.close()
+    conn.close()
+
+except Exception as e:
+    print(f"❌ Error: {e}")
+    import traceback
+    traceback.print_exc()
+

debug_properties.py

@@ -0,0 +1,113 @@
+"""
+Скрипт для детальной проверки состояния properties в БД
+"""
+import psycopg2
+
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+try:
+    conn = psycopg2.connect(**DB_CONFIG)
+    cursor = conn.cursor()
+
+    print("=" * 70)
+    print("DETAILED PROPERTIES CHECK")
+    print("=" * 70)
+
+    # Проверяем общее количество
+    cursor.execute("SELECT COUNT(*) FROM properties")
+    total = cursor.fetchone()[0]
+    print(f"\n📊 Total properties: {total}")
+
+    # Проверяем по owner_user_id
+    cursor.execute("""
+        SELECT owner_user_id, COUNT(*)
+        FROM properties
+        GROUP BY owner_user_id
+        ORDER BY COUNT(*) DESC
+    """)
+    print(f"\n👥 Properties by owner:")
+    for owner_id, count in cursor.fetchall():
+        print(f"  {owner_id}: {count} properties")
+
+    # Проверяем, существуют ли эти пользователи
+    print(f"\n🔍 Checking if owners exist in users table:")
+    cursor.execute("""
+        SELECT p.owner_user_id, u.email, u.role, COUNT(p.property_id) as prop_count
+        FROM properties p
+        LEFT JOIN users u ON p.owner_user_id = u.user_id
+        GROUP BY p.owner_user_id, u.email, u.role
+    """)
+    for owner_id, email, role, count in cursor.fetchall():
+        if email:
+            print(f"  ✅ {owner_id[:8]}... → {email} ({role}) - {count} props")
+        else:
+            print(f"  ❌ {owner_id[:8]}... → USER NOT FOUND! - {count} props (will be deleted on cascade)")
+
+    # Проверяем ограничения (constraints)
+    print(f"\n🔗 Foreign key constraints on properties:")
+    cursor.execute("""
+        SELECT
+            tc.constraint_name,
+            tc.constraint_type,
+            kcu.column_name,
+            ccu.table_name AS foreign_table_name,
+            ccu.column_name AS foreign_column_name,
+            rc.delete_rule
+        FROM information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+        LEFT JOIN information_schema.referential_constraints AS rc
+          ON tc.constraint_name = rc.constraint_name
+        WHERE tc.table_name = 'properties' AND tc.constraint_type = 'FOREIGN KEY'
+    """)
+
+    for constraint_name, constraint_type, column, foreign_table, foreign_column, delete_rule in cursor.fetchall():
+        print(f"  {column} → {foreign_table}.{foreign_column}")
+        print(f"    Delete rule: {delete_rule}")
+
+    # Показываем примеры объектов
+    print(f"\n📄 Sample properties (first 5):")
+    cursor.execute("""
+        SELECT property_id, title, owner_user_id, created_at
+        FROM properties
+        ORDER BY created_at DESC
+        LIMIT 5
+    """)
+    for prop_id, title, owner_id, created in cursor.fetchall():
+        print(f"  - {title[:50]}...")
+        print(f"    ID: {prop_id}")
+        print(f"    Owner: {owner_id}")
+        print(f"    Created: {created}")
+
+    # Проверяем пользователя f4e8f58b...
+    print(f"\n🔍 Checking specific admin user (f4e8f58b-94f4-4e0f-bd85-1b06b8a3f242):")
+    cursor.execute("""
+        SELECT user_id, email, role, first_name, last_name
+        FROM users
+        WHERE user_id = 'f4e8f58b-94f4-4e0f-bd85-1b06b8a3f242'
+    """)
+    result = cursor.fetchone()
+    if result:
+        print(f"  ✅ User exists: {result[1]} ({result[2]}) - {result[3]} {result[4]}")
+    else:
+        print(f"  ❌ User NOT FOUND! This is why properties are being deleted!")
+        print(f"  ℹ️  Properties reference a user that doesn't exist")
+
+    print("\n" + "=" * 70)
+
+    cursor.close()
+    conn.close()
+
+except Exception as e:
+    print(f"❌ Error: {e}")
+    import traceback
+    traceback.print_exc()
+

deploy_to_hf.bat

@@ -0,0 +1,34 @@
+@echo off
+REM Скрипт для обновления сервиса на HuggingFace Spaces
+
+echo.
+echo ======================================================================
+echo DEPLOYING UPDATED SERVICE TO HUGGINGFACE SPACES
+echo ======================================================================
+echo.
+
+cd huggingface
+
+echo Current changes:
+git status
+
+echo.
+echo Committing changes...
+git add -A
+git commit -m "Fix: Update to RoSBERTa model (1024 dims), remove half precision, increase timeout"
+
+echo.
+echo Pushing to HuggingFace Spaces...
+git push
+
+echo.
+echo ======================================================================
+echo DEPLOYMENT COMPLETE
+echo ======================================================================
+echo.
+echo Wait ~2-3 minutes for HuggingFace Spaces to rebuild and restart
+echo Then run: python check_service_status.py
+echo.
+
+pause
+

huggingface/Dockerfile

@@ -18,8 +18,9 @@ ENV PYTHONUNBUFFERED=1
 ENV TRANSFORMERS_CACHE=/home/user/.cache/transformers
 ENV SENTENCE_TRANSFORMERS_HOME=/home/user/.cache/sentence_transformers
 ENV HF_HOME=/home/user/.cache/huggingface
-ENV EMBEDDING_MODEL=sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
-ENV EMBEDDING_DIMENSIONS=384
+# Model settings
+ENV EMBEDDING_MODEL=ai-forever/ru-en-RoSBERTa
+ENV EMBEDDING_DIMENSIONS=1024
 
 # Copy requirements and install dependencies
 COPY --chown=user requirements.txt .

huggingface/main.py

@@ -28,8 +28,8 @@ from dotenv import load_dotenv
 load_dotenv()
 
 # Конфигурация
-MODEL_NAME = os.getenv("EMBEDDING_MODEL", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
-EMBEDDING_DIMENSIONS = 384
+MODEL_NAME = os.getenv("EMBEDDING_MODEL", "ai-forever/ru-en-RoSBERTa")
+EMBEDDING_DIMENSIONS = 1024  # RoSBERTa actual dimensions (verified)
 
 # Глобальная модель
 model: Optional[SentenceTransformer] = None
@@ -41,12 +41,9 @@ async def lifespan(app: FastAPI):
     global model
     print(f"Loading embedding model: {MODEL_NAME}")
     model = SentenceTransformer(MODEL_NAME, device='cpu')
-    try:
-        model.half()
-        print("Model converted to half precision (float16)")
-    except Exception as e:
-        print(f"Could not convert to half precision: {e}")
-    print(f"Model loaded. Dimensions: {model.get_sentence_embedding_dimension()}")
+    # NOTE: half precision (float16) может вызывать ошибки на CPU
+    # Используем float32 для лучшей совместимости
+    print(f"Model loaded in full precision (float32). Dimensions: {model.get_sentence_embedding_dimension()}")
     yield
     model = None
 

index_all_properties.py

@@ -0,0 +1,256 @@
+"""
+Скрипт для индексации всех объектов недвижимости через HuggingFace Spaces сервис
+
+Usage:
+    python index_all_properties.py          # Интерактивный режим
+    python index_all_properties.py --yes    # Автоподтверждение
+"""
+import psycopg2
+import requests
+import time
+import sys
+from typing import List, Dict, Any
+
+# Конфигурация БД
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+# URL сервиса на HuggingFace Spaces
+HF_SERVICE_URL = "https://calcifer0323-matching.hf.space"
+
+def get_properties_from_db() -> List[Dict[str, Any]]:
+    """Получить все объекты недвижимости из БД"""
+    print("📥 Fetching properties from database...")
+
+    conn = psycopg2.connect(**DB_CONFIG)
+    cursor = conn.cursor()
+
+    cursor.execute("""
+        SELECT property_id, title, description, address, property_type,
+               area, price, rooms, status
+        FROM properties
+        ORDER BY created_at DESC
+    """)
+
+    columns = ['property_id', 'title', 'description', 'address', 'property_type',
+               'area', 'price', 'rooms', 'status']
+
+    properties = []
+    for row in cursor.fetchall():
+        prop = dict(zip(columns, row))
+        properties.append(prop)
+
+    cursor.close()
+    conn.close()
+
+    print(f"✅ Fetched {len(properties)} properties")
+    return properties
+
+def prepare_text_for_property(prop: Dict[str, Any]) -> str:
+    """Подготовить текст для генерации эмбеддинга"""
+    parts = []
+
+    if prop.get('title'):
+        parts.append(f"Название: {prop['title']}")
+
+    if prop.get('description'):
+        parts.append(f"Описание: {prop['description']}")
+
+    if prop.get('address'):
+        parts.append(f"Адрес: {prop['address']}")
+
+    # Добавляем структурированные данные
+    details = []
+    if prop.get('property_type'):
+        details.append(f"тип: {prop['property_type']}")
+    if prop.get('rooms'):
+        details.append(f"комнат: {prop['rooms']}")
+    if prop.get('area'):
+        details.append(f"площадь: {prop['area']} м²")
+    if prop.get('price'):
+        details.append(f"цена: {prop['price']:,} ₽")
+
+    if details:
+        parts.append("Характеристики: " + ", ".join(details))
+
+    return ". ".join(parts)
+
+def index_batch(properties: List[Dict[str, Any]], batch_size: int = 20) -> Dict[str, Any]:
+    """Индексировать батч объектов через HuggingFace Spaces"""
+    items = []
+
+    for prop in properties:
+        # Подготавливаем данные для эндпоинта /batch
+        item = {
+            "entity_id": str(prop['property_id']),
+            "title": prop.get('title', ''),
+            "description": prop.get('description', ''),
+            "price": float(prop['price']) if prop.get('price') else None,
+            "rooms": int(prop['rooms']) if prop.get('rooms') else None,
+            "area": float(prop['area']) if prop.get('area') else None,
+            "address": prop.get('address', ''),
+            "district": ""  # Можно извлечь из address если нужно
+        }
+        items.append(item)
+
+    payload = {"items": items}
+
+    try:
+        print(f"  📤 Sending batch of {len(items)} items to {HF_SERVICE_URL}/batch")
+        print(f"     Payload size: {len(str(payload))} bytes")
+
+        response = requests.post(
+            f"{HF_SERVICE_URL}/batch",
+            json=payload,
+            timeout=120  # 2 минуты на батч (было 5 минут, но timeout на сервере 30с)
+        )
+
+        print(f"     Response status: {response.status_code}")
+
+        if response.status_code == 200:
+            result = response.json()
+            return result
+        else:
+            print(f"  ❌ Error: {response.status_code}")
+            print(f"     Response: {response.text[:500]}")
+
+            # Пробуем получить более детальную информацию об ошибке
+            try:
+                error_detail = response.json()
+                print(f"     Detail: {error_detail}")
+            except:
+                pass
+
+            return None
+
+    except requests.exceptions.Timeout:
+        print(f"  ❌ Request timeout (120 seconds)")
+        return None
+    except requests.exceptions.ConnectionError as e:
+        print(f"  ❌ Connection error: {e}")
+        return None
+    except requests.exceptions.RequestException as e:
+        print(f"  ❌ Request failed: {e}")
+        return None
+
+def save_embeddings_to_file(results: List[Dict], filename: str = "generated_embeddings.json"):
+    """��охранить результаты индексации в файл (для проверки)"""
+    import json
+
+    with open(filename, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+
+    print(f"💾 Saved embeddings to {filename}")
+
+def main():
+    print("=" * 70)
+    print("INDEXING PROPERTIES THROUGH HUGGINGFACE SPACES")
+    print("=" * 70)
+
+    # Проверяем параметры командной строки
+    auto_confirm = '--yes' in sys.argv or '-y' in sys.argv
+
+    if auto_confirm:
+        print("🤖 Auto-confirm mode enabled")
+
+    # 1. Получаем объекты из БД
+    properties = get_properties_from_db()
+
+    if not properties:
+        print("⚠️  No properties found in database")
+        return
+
+    print(f"\n📊 Total properties to index: {len(properties)}")
+
+    # Показываем пример
+    print(f"\n📄 Sample property:")
+    sample = properties[0]
+    print(f"  ID: {sample['property_id']}")
+    print(f"  Title: {sample.get('title', 'N/A')}")
+    print(f"  Text preview: {prepare_text_for_property(sample)[:150]}...")
+
+    # Подтверждение
+    if not auto_confirm:
+        print(f"\n🚀 Ready to index {len(properties)} properties")
+        print(f"   Service: {HF_SERVICE_URL}")
+        print(f"   Endpoint: /batch")
+
+        try:
+            response = input("\nProceed? (yes/y/no/n): ")
+            if response.lower() not in ['yes', 'y']:
+                print("Cancelled by user")
+                return
+        except EOFError:
+            print("\n❌ Error: EOF when reading input")
+            print("Run with --yes flag to auto-confirm: python index_all_properties.py --yes")
+            return
+    else:
+        print(f"\n✅ Auto-confirming indexing of {len(properties)} properties")
+        print(f"   Service: {HF_SERVICE_URL}")
+        print(f"   Endpoint: /batch")
+
+    # 2. Индексируем батчами
+    batch_size = 20  # Уменьшено с 50 до 20 (время обработки ~30 сек на сервере)
+    total_batches = (len(properties) + batch_size - 1) // batch_size
+
+    print(f"\n📦 Processing {total_batches} batches (batch size: {batch_size})")
+    print(f"   ⏱️  Each batch will take ~30-40 seconds to process")
+    print(f"   📊 Total time estimate: ~{(total_batches * 35) // 60} minutes")
+
+    all_results = []
+    successful = 0
+    failed = 0
+
+    for i in range(0, len(properties), batch_size):
+        batch = properties[i:i + batch_size]
+        batch_num = i // batch_size + 1
+
+        print(f"\n🔄 Batch {batch_num}/{total_batches} ({len(batch)} items)")
+
+        result = index_batch(batch, batch_size)
+
+        if result:
+            all_results.append(result)
+            batch_successful = result.get('successful', 0)
+            batch_failed = result.get('failed', 0)
+            successful += batch_successful
+            failed += batch_failed
+
+            print(f"  ✅ Success: {batch_successful}/{len(batch)}")
+            if batch_failed > 0:
+                print(f"  ⚠️  Failed: {batch_failed}")
+        else:
+            print(f"  ❌ Batch failed completely")
+            failed += len(batch)
+
+        # Задержка между батчами
+        if i + batch_size < len(properties):
+            print(f"  ⏳ Waiting 10 seconds before next batch...")
+            time.sleep(10)
+
+    # 3. Сохраняем результаты
+    if all_results:
+        save_embeddings_to_file(all_results, "indexing_results.json")
+
+    # 4. Итоги
+    print("\n" + "=" * 70)
+    print("INDEXING COMPLETE")
+    print("=" * 70)
+    print(f"✅ Successfully indexed: {successful}/{len(properties)}")
+    print(f"❌ Failed: {failed}/{len(properties)}")
+
+    if successful > 0:
+        print(f"\n💡 Note: Embeddings were generated on HuggingFace Spaces")
+        print(f"   Results saved to: indexing_results.json")
+        print(f"   Backend should fetch these embeddings and store in DB")
+
+    print("\n" + "=" * 70)
+
+if __name__ == '__main__':
+    main()
+

index_objects.py

@@ -0,0 +1,169 @@
+import requests
+import json
+import re
+import sqlite3
+import time
+
+# Читаем SQL файл
+with open('pars_samolet.sql', 'r', encoding='utf-8') as f:
+    sql_content = f.read()
+
+# Извлекаем CREATE TABLE
+create_match = re.search(r'CREATE TABLE[^;]+;', sql_content, re.DOTALL)
+if not create_match:
+    raise ValueError("CREATE TABLE not found")
+create_stmt = create_match.group(0)
+
+# Извлекаем все INSERT
+insert_pattern = r'INSERT INTO mytable\([^)]+\) VALUES\s*\([^;]+\);'
+inserts = re.findall(insert_pattern, sql_content, re.DOTALL)
+
+# Создаем временную базу для парсинга
+conn = sqlite3.connect(':memory:')
+cursor = conn.cursor()
+cursor.execute(create_stmt)
+
+# Функция для экранирования SQL-строк
+def escape_sql_value(value):
+    if value is None:
+        return 'NULL'
+    # Заменяем одинарные кавычки на две одинарные кавычки
+    return str(value).replace("'", "''")
+
+# Выполняем INSERT с экранированием
+for insert in inserts:
+    try:
+        cursor.execute(insert)
+    except sqlite3.OperationalError as e:
+        # Если есть ошибка, пытаемся очистить строку от проблемных символов
+        # Находим VALUES часть
+        match = re.search(r'VALUES\s*\((.+)\);', insert, re.DOTALL)
+        if match:
+            values_str = match.group(1)
+            # Разбиваем значения по запятым, учитывая строки в кавычках
+            values = []
+            current = ''
+            in_string = False
+            for char in values_str:
+                if char == "'" and (len(current) == 0 or current[-1] != '\\'):
+                    in_string = not in_string
+                current += char
+                if not in_string and char == ',':
+                    values.append(current[:-1].strip())
+                    current = ''
+            if current:
+                values.append(current.strip())
+
+            # Экранируем каждое строковое значение
+            cleaned_values = []
+            for val in values:
+                if val.upper() == 'NULL':
+                    cleaned_values.append('NULL')
+                elif val.startswith("'") and val.endswith("'"):
+                    # Это строковое значение
+                    inner = val[1:-1]
+                    # Удаляем лишние переводы строк и табуляции
+                    inner = inner.replace('\n', ' ').replace('\r', ' ')
+                    inner = ' '.join(inner.split())  # Удаляем лишние пробелы
+                    inner = escape_sql_value(inner)
+                    cleaned_values.append(f"'{inner}'")
+                else:
+                    # Числовое или другое значение
+                    cleaned_values.append(val)
+
+            # Собираем новый INSERT
+            insert_start = insert[:match.start(1)]
+            insert_end = insert[match.end(1):]
+            new_insert = insert_start + ', '.join(cleaned_values) + insert_end
+
+            try:
+                cursor.execute(new_insert)
+                print(f"Fixed problematic INSERT")
+            except Exception as e2:
+                print(f"Still failed to execute INSERT: {e2}")
+                # Пропускаем проблемную запись
+                continue
+        else:
+            print(f"Could not parse INSERT: {insert[:100]}...")
+            continue
+
+# Получаем данные
+cursor.execute('SELECT * FROM mytable')
+rows = cursor.fetchall()
+
+# Получаем имена колонок
+cursor.execute("PRAGMA table_info(mytable)")
+columns = [col[1] for col in cursor.fetchall()]
+
+# Создаем список словарей
+objects = [dict(zip(columns, row)) for row in rows]
+conn.close()
+
+print(f"Total objects parsed: {len(objects)}")
+
+# Разделяем на батчи по 10, берем первые 4
+batch_size = 50
+batches = [objects[i:i + batch_size] for i in range(0, len(objects), batch_size)][:4]
+
+# URL для API
+url = 'https://calcifer0323-matching.hf.space/batch'
+
+responses = []
+for i, batch in enumerate(batches):
+    print(f"Sending batch {i+1} with {len(batch)} objects")
+
+    # Преобразуем объекты в items для /batch
+    items = []
+    for obj in batch:
+        item = {
+            "entity_id": str(obj["property_id"]),
+            "title": str(obj.get("title", "")),
+            "description": str(obj.get("description", "")),
+            "price": float(obj.get("price", 0)) if obj.get("price") else None,
+            "rooms": float(obj.get("rooms", 0)) if obj.get("rooms") else None,
+            "area": float(obj.get("area", 0)) if obj.get("area") else None,
+            "address": str(obj.get("address", "")),
+            "district": str(obj.get("city", ""))
+        }
+        items.append(item)
+
+    payload = {"items": items}
+
+    try:
+        response = requests.post(url, json=payload, timeout=300)
+        if response.status_code == 200:
+            data = response.json()
+            responses.append(data)
+            successful = data.get('successful', 0)
+            total = data.get('total', 0)
+            print(f"Batch {i+1} successful, embedded {successful}/{total}")
+        else:
+            print(f"Batch {i+1} failed: {response.status_code} - {response.text}")
+    except Exception as e:
+        print(f"Error sending batch {i+1}: {e}")
+
+    # Задержка между батчами
+    if i < len(batches) - 1:
+        print("Waiting 10 seconds before next batch...")
+        time.sleep(10)
+
+# Сохраняем результаты в SQL файл
+with open('indexed_objects.sql', 'w', encoding='utf-8') as f:
+    f.write("CREATE TABLE IF NOT EXISTS indexed_objects (\n")
+    f.write("    property_id VARCHAR(36) PRIMARY KEY,\n")
+    f.write("    embedding JSON\n")
+    f.write(");\n\n")
+
+    f.write("DELETE FROM indexed_objects;\n\n")
+
+    for resp in responses:
+        for result in resp.get("results", []):
+            if result.get("success"):
+                property_id = result["entity_id"]
+                embedding = json.dumps(result["embedding"])
+                # Экранируем для SQL
+                embedding_escaped = embedding.replace("'", "''")
+                f.write(f"INSERT INTO indexed_objects (property_id, embedding) VALUES ('{property_id}', '{embedding_escaped}');\n")
+
+print(f"Indexing complete. Results saved to indexed_objects.sql")
+print(f"Total batches processed: {len(responses)}")

requirements-scripts.txt

@@ -0,0 +1,6 @@
+# Зависимости для вспомогательных скриптов
+# Установка: pip install -r requirements-scripts.txt
+
+psycopg2-binary>=2.9.9  # PostgreSQL адаптер
+bcrypt>=4.1.2           # Хеширование паролей
+

test_db_connection.py

@@ -0,0 +1,74 @@
+"""
+Тестовый скрипт для проверки подключения к БД
+"""
+try:
+    import psycopg2
+    print("✅ psycopg2 installed")
+except ImportError:
+    print("❌ psycopg2 not installed. Run: pip install psycopg2-binary")
+    exit(1)
+
+try:
+    import bcrypt
+    print("✅ bcrypt installed")
+except ImportError:
+    print("❌ bcrypt not installed. Run: pip install bcrypt")
+    exit(1)
+
+# Данные подключения
+DB_CONFIG = {
+    'host': 'dpg-d5ht8vi4d50c739akh2g-a.virginia-postgres.render.com',
+    'port': 5432,
+    'database': 'lead_exchange_bk',
+    'user': 'lead_exchange_bk_user',
+    'password': '8m2gtTRBW0iAr7nY2Aadzz0VcZBEVKYM'
+}
+
+print(f"\nConnecting to {DB_CONFIG['host']}...")
+
+try:
+    conn = psycopg2.connect(**DB_CONFIG)
+    print("✅ Connected successfully!")
+
+    cursor = conn.cursor()
+
+    # Проверяем таблицы
+    cursor.execute("""
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+        ORDER BY table_name
+    """)
+
+    tables = cursor.fetchall()
+    print(f"\n📋 Tables in database:")
+    for table in tables:
+        print(f"  - {table[0]}")
+
+    # Проверяем пользователей
+    cursor.execute("SELECT COUNT(*) FROM users")
+    user_count = cursor.fetchone()[0]
+    print(f"\n👤 Users count: {user_count}")
+
+    if user_count > 0:
+        cursor.execute("SELECT email, role FROM users LIMIT 5")
+        users = cursor.fetchall()
+        print("  Sample users:")
+        for email, role in users:
+            print(f"    - {email} ({role})")
+
+    # Проверяем properties
+    cursor.execute("SELECT COUNT(*) FROM properties")
+    prop_count = cursor.fetchone()[0]
+    print(f"\n🏠 Properties count: {prop_count}")
+
+    cursor.close()
+    conn.close()
+
+    print("\n✅ All checks passed!")
+
+except psycopg2.Error as e:
+    print(f"\n❌ Database error: {e}")
+except Exception as e:
+    print(f"\n❌ Error: {e}")
+