pip install requests pandas beautifulsoup4

import requests

# Базовая настройка
FIRECRAWL_API_KEY = "your_api_key_here"
BASE_URL = "https://api.firecrawl.ru/v1"
headers = {"X-API-Key": FIRECRAWL_API_KEY}

# Парсинг страницы
def scrape_page(url):
    response = requests.post(f"{BASE_URL}/scrape", 
        headers=headers,
        json={"url": url, "formats": ["markdown"]}
    )
    return response.json()

# Использование
result = scrape_page("https://example.com")
print(result['data']['markdown'])

import pandas as pd
import requests
from urllib.parse import urljoin

class FirecrawlClient:
    def __init__(self, api_key):
        self.headers = {"X-API-Key": api_key}
        self.base_url = "https://api.firecrawl.ru/v1"
    
    def search_to_dataframe(self, query, limit=10):
        """Поиск с результатами в Pandas DataFrame"""
        response = requests.post(f"{self.base_url}/search", 
            headers=self.headers,
            json={
                "query": query,
                "limit": limit,
                "parseResults": False
            }
        )
        
        data = response.json()
        if data.get('success') and data['data']['pages']:
            df = pd.DataFrame(data['data']['pages'])
            df['scraped_at'] = pd.Timestamp.now()
            return df
        return pd.DataFrame()
    
    def scrape_urls_batch(self, urls):
        """Массовый парсинг URL с результатами в DataFrame"""
        results = []
        
        for url in urls:
            try:
                response = requests.post(f"{self.base_url}/scrape",
                    headers=self.headers,
                    json={
                        "url": url,
                        "formats": ["markdown"],
                        "onlyMainContent": True
                    }
                )
                
                data = response.json()
                if data.get('success'):
                    results.append({
                        'url': url,
                        'title': data['data'].get('metadata', {}).get('title', ''),
                        'content': data['data']['markdown'],
                        'word_count': len(data['data']['markdown'].split()),
                        'scraped_at': pd.Timestamp.now(),
                        'success': True
                    })
                else:
                    results.append({
                        'url': url, 
                        'error': data.get('error', 'Unknown error'),
                        'success': False
                    })
                    
            except Exception as e:
                results.append({'url': url, 'error': str(e), 'success': False})
        
        return pd.DataFrame(results)
    
    def ai_analyze_batch(self, queries):
        """AI анализ множества запросов"""
        results = []
        
        for query in queries:
            response = requests.post(f"{self.base_url}/search",
                headers=self.headers,
                json={
                    "query": query,
                    "limit": 3,
                    "parseResults": True,
                    "aiPrompt": f"Кратко проанализируй тренды по запросу: {query}"
                }
            )
            
            data = response.json()
            if data.get('success'):
                results.append({
                    'query': query,
                    'ai_analysis': data['data'].get('markdown', ''),
                    'sources_count': len(data['data'].get('pages', [])),
                    'analyzed_at': pd.Timestamp.now()
                })
        
        return pd.DataFrame(results)

# Использование
client = FirecrawlClient("your_api_key")

# Поиск конкурентов
competitors_df = client.search_to_dataframe("конкуренты веб-скрейпинг", limit=20)
print(competitors_df.head())

# Анализ трендов
trends = ["ИИ в бизнесе", "блокчейн технологии", "зеленая энергия"]
trends_df = client.ai_analyze_batch(trends)
print(trends_df['ai_analysis'])

import matplotlib.pyplot as plt
import seaborn as sns

# Анализ контента по ключевым словам
def analyze_content_trends(search_queries):
    client = FirecrawlClient("your_api_key")
    all_data = []
    
    for query in search_queries:
        df = client.search_to_dataframe(query, limit=15)
        df['search_query'] = query
        all_data.append(df)
    
    combined_df = pd.concat(all_data, ignore_index=True)
    
    # Визуализация результатов
    plt.figure(figsize=(12, 6))
    
    # График по запросам
    plt.subplot(1, 2, 1)
    query_counts = combined_df['search_query'].value_counts()
    query_counts.plot(kind='bar')
    plt.title('Количество результатов по запросам')
    plt.xticks(rotation=45)
    
    # График по доменам
    plt.subplot(1, 2, 2)
    top_domains = combined_df['url'].str.extract(r'https?://([^/]+)')[0].value_counts().head(10)
    top_domains.plot(kind='barh')
    plt.title('Топ-10 доменов')
    
    plt.tight_layout()
    plt.show()
    
    return combined_df

# Пример использования
queries = ["python web scraping", "machine learning trends", "data science 2025"]
results_df = analyze_content_trends(queries)

import schedule
import time
from datetime import datetime
import json

class AutomatedScraper:
    def __init__(self, api_key):
        self.client = FirecrawlClient(api_key)
        self.results_history = []
    
    def daily_competitor_analysis(self):
        """Ежедневный анализ конкурентов"""
        competitors = [
            "https://competitor1.com",
            "https://competitor2.com", 
            "https://competitor3.com"
        ]
        
        results_df = self.client.scrape_urls_batch(competitors)
        
        # Сохранение результатов
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        results_df.to_csv(f"competitors_analysis_{timestamp}.csv", index=False)
        
        # Отправка отчета (например, на email)
        summary = {
            'date': datetime.now().isoformat(),
            'total_urls': len(competitors),
            'successful_scrapes': results_df['success'].sum(),
            'average_word_count': results_df['word_count'].mean()
        }
        
        print(f"📊 Ежедневный отчет: {json.dumps(summary, indent=2)}")
        return results_df
    
    def weekly_market_research(self):
        """Еженедельное исследование рынка"""
        market_topics = [
            "новые технологии стартапы",
            "инвестиции в ИТ",
            "тренды digital маркетинг"
        ]
        
        research_df = self.client.ai_analyze_batch(market_topics)
        
        # Создание еженедельного отчета
        timestamp = datetime.now().strftime("%Y_week_%U")
        research_df.to_excel(f"market_research_{timestamp}.xlsx", index=False)
        
        return research_df

# Настройка планировщика
scraper = AutomatedScraper("your_api_key")

schedule.every().day.at("09:00").do(scraper.daily_competitor_analysis)
schedule.every().monday.at("10:00").do(scraper.weekly_market_research)

# Запуск планировщика
print("🚀 Автоматизация запущена!")
while True:
    schedule.run_pending()
    time.sleep(60)

# Установка в Jupyter
!pip install requests pandas matplotlib seaborn wordcloud

import requests
import pandas as pd
import matplotlib.pyplot as plt
from wordcloud import WordCloud

# Быстрый анализ контента
def quick_content_analysis(search_query):
    """Быстрый анализ контента для Jupyter"""
    
    headers = {"X-API-Key": "your_api_key"}
    response = requests.post("https://api.firecrawl.ru/v1/search",
        headers=headers,
        json={
            "query": search_query,
            "limit": 10,
            "parseResults": True,
            "aiPrompt": f"Проанализируй ключевые темы по запросу: {search_query}"
        }
    )
    
    data = response.json()
    
    if data.get('success'):
        # Результаты поиска
        pages_df = pd.DataFrame(data['data']['pages'])
        display(pages_df.head())
        
        # AI анализ
        if 'markdown' in data['data']:
            print("🤖 AI Анализ:")
            print(data['data']['markdown'])
        
        # Облако слов из заголовков
        if not pages_df.empty:
            titles_text = " ".join(pages_df['title'].fillna(''))
            wordcloud = WordCloud(width=800, height=400, 
                                background_color='white',
                                colormap='viridis').generate(titles_text)
            
            plt.figure(figsize=(10, 5))
            plt.imshow(wordcloud, interpolation='bilinear')
            plt.axis('off')
            plt.title(f'Облако слов: "{search_query}"')
            plt.show()
    
    return data

# Использование в Jupyter
result = quick_content_analysis("искусственный интеллект 2025")

import sqlite3
from sqlalchemy import create_engine

class FirecrawlDataManager:
    def __init__(self, api_key, db_path="scraping_results.db"):
        self.client = FirecrawlClient(api_key)
        self.engine = create_engine(f'sqlite:///{db_path}')
    
    def scrape_and_store(self, urls, table_name="scraped_content"):
        """Парсинг с сохранением в БД"""
        results_df = self.client.scrape_urls_batch(urls)
        
        # Сохранение в SQLite
        results_df.to_sql(table_name, self.engine, 
                         if_exists='append', index=False)
        
        print(f"* Сохранено {len(results_df)} записей в таблицу {table_name}")
        return results_df
    
    def get_stored_data(self, table_name="scraped_content", 
                       days_back=7):
        """Получение сохраненных данных"""
        query = f"""
        SELECT * FROM {table_name} 
        WHERE scraped_at >= datetime('now', '-{days_back} days')
        ORDER BY scraped_at DESC
        """
        
        return pd.read_sql_query(query, self.engine)

# Использование
dm = FirecrawlDataManager("your_api_key")

# Парсинг списка новостных сайтов
news_urls = [
    "https://habr.com",
    "https://vc.ru", 
    "https://rb.ru"
]

results = dm.scrape_and_store(news_urls, "news_analysis")

# Утилиты для работы с Firecrawl
import re
from urllib.parse import urljoin, urlparse

def clean_markdown(text):
    """Очистка markdown от лишних символов"""
    # Удаление множественных переносов строк
    text = re.sub(r'\n{3,}', '\n\n', text)
    # Удаление лишних пробелов
    text = re.sub(r'[ \t]+', ' ', text)
    return text.strip()

def extract_links_from_markdown(markdown_content, base_url=""):
    """Извлечение ссылок из markdown"""
    link_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
    links = re.findall(link_pattern, markdown_content)
    
    result = []
    for text, url in links:
        if base_url and not url.startswith('http'):
            url = urljoin(base_url, url)
        result.append({'text': text, 'url': url})
    
    return result

def summarize_content(content, max_words=100):
    """Краткое резюме контента"""
    words = content.split()
    if len(words) <= max_words:
        return content
    
    summary = ' '.join(words[:max_words])
    return summary + '...'

# Расширенная статистика
def content_statistics(content):
    """Подробная статистика контента"""
    return {
        'word_count': len(content.split()),
        'char_count': len(content),
        'paragraph_count': len(content.split('\n\n')),
        'avg_words_per_paragraph': len(content.split()) / max(len(content.split('\n\n')), 1),
        'reading_time_minutes': len(content.split()) / 200  # ~200 слов в минуту
    }

# Ежедневная проверка цен конкурентов
competitors = ["competitor1.com/pricing", "competitor2.com/plans"]
price_data = client.scrape_urls_batch(competitors)
# Анализ изменений цен...

# Поиск трендовых тем для блога
trends = client.search_to_dataframe("тренды digital marketing", limit=50)
# Генерация идей контента...

# Анализ топ-10 по ключевому слову
seo_data = client.search_to_dataframe("веб разработка услуги", limit=10)
# Анализ заголовков, мета-описаний...