Claude 3.7 Maxの全貌：最新AIモデルの進化と特長

#!/usr/bin/env python3
import requests
import whois
import dns.resolver
import socket
from bs4 import BeautifulSoup
import json
import time
import re
from urllib.parse import urlparse, urljoin
import ssl
import datetime

class DomainAnalyzer:
    def __init__(self, domain):
        self.domain = domain
        self.url = f"https://{domain}"
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        self.results = {
            "domain": domain,
            "whois_info": {},
            "dns_info": {},
            "website_info": {},
            "backlinks": [],
            "estimated_domain_power": 0
        }
    
    def analyze_whois(self):
        """Analyze WHOIS information for the domain"""
        try:
            w = whois.whois(self.domain)
            
            # Extract relevant WHOIS information
            self.results["whois_info"] = {
                "registrar": w.registrar,
                "creation_date": str(w.creation_date[0] if isinstance(w.creation_date, list) else w.creation_date),
                "expiration_date": str(w.expiration_date[0] if isinstance(w.expiration_date, list) else w.expiration_date),
                "last_updated": str(w.updated_date[0] if isinstance(w.updated_date, list) else w.updated_date),
                "name_servers": w.name_servers if isinstance(w.name_servers, list) else [w.name_servers] if w.name_servers else []
            }
            
            # Calculate domain age in days
            if w.creation_date:
                creation_date = w.creation_date[0] if isinstance(w.creation_date, list) else w.creation_date
                if creation_date:
                    domain_age_days = (datetime.datetime.now() - creation_date).days
                    self.results["whois_info"]["domain_age_days"] = domain_age_days
                    
                    # Domain age contributes to domain power (older domains tend to have more authority)
                    age_factor = min(domain_age_days / 3650, 1)  # Max factor for domains 10+ years old
                    self.results["estimated_domain_power"] += age_factor * 20  # Up to 20 points for age
            
            return True
        except Exception as e:
            self.results["whois_info"] = {"error": str(e)}
            return False
    
    def analyze_dns(self):
        """Analyze DNS records for the domain"""
        try:
            dns_info = {}
            
            # A records
            try:
                a_records = dns.resolver.resolve(self.domain, 'A')
                dns_info["a_records"] = [record.to_text() for record in a_records]
            except:
                dns_info["a_records"] = []
            
            # MX records
            try:
                mx_records = dns.resolver.resolve(self.domain, 'MX')
                dns_info["mx_records"] = [record.to_text() for record in mx_records]
            except:
                dns_info["mx_records"] = []
            
            # TXT records
            try:
                txt_records = dns.resolver.resolve(self.domain, 'TXT')
                dns_info["txt_records"] = [record.to_text() for record in txt_records]
            except:
                dns_info["txt_records"] = []
            
            # NS records
            try:
                ns_records = dns.resolver.resolve(self.domain, 'NS')
                dns_info["ns_records"] = [record.to_text() for record in ns_records]
            except:
                dns_info["ns_records"] = []
            
            self.results["dns_info"] = dns_info
            
            # DNS setup quality contributes to domain power
            dns_quality_score = 0
            if dns_info.get("mx_records"):
                dns_quality_score += 5  # Has email setup
            if dns_info.get("txt_records"):
                dns_quality_score += 5  # Has SPF/DKIM/etc.
            if len(dns_info.get("ns_records", [])) >= 2:
                dns_quality_score += 5  # Has multiple nameservers
                
            self.results["estimated_domain_power"] += dns_quality_score
            
            return True
        except Exception as e:
            self.results["dns_info"] = {"error": str(e)}
            return False
    
    def analyze_website(self):
        """Analyze website content and metadata"""
        try:
            response = requests.get(self.url, headers=self.headers, timeout=10)
            if response.status_code == 200:
                soup = BeautifulSoup(response.text, 'html.parser')
                
                # Extract title and meta description
                title = soup.title.string if soup.title else ""
                meta_description = ""
                meta_desc_tag = soup.find("meta", attrs={"name": "description"})
                if meta_desc_tag:
                    meta_description = meta_desc_tag.get("content", "")
                
                # Count links
                all_links = soup.find_all('a', href=True)
                internal_links = []
                external_links = []
                
                for link in all_links:
                    href = link['href']
                    if href.startswith('#') or not href:
                        continue
                    
                    # Convert relative URLs to absolute
                    if not href.startswith(('http://', 'https://')):
                        href = urljoin(self.url, href)
                    
                    parsed_href = urlparse(href)
                    if parsed_href.netloc == self.domain or parsed_href.netloc == f"www.{self.domain}":
                        internal_links.append(href)
                    else:
                        external_links.append(href)
                
                # Check for SSL
                has_ssl = self.url.startswith("https://")
                
                # Check for social media links
                social_media_patterns = [
                    "facebook.com", "twitter.com", "instagram.com", 
                    "linkedin.com", "youtube.com", "pinterest.com",
                    "tiktok.com"
                ]
                social_media_links = []
                
                for link in external_links:
                    for pattern in social_media_patterns:
                        if pattern in link:
                            social_media_links.append(link)
                            break
                
                # Estimate content quality
                word_count = len(response.text.split())
                
                self.results["website_info"] = {
                    "title": title,
                    "meta_description": meta_description,
                    "internal_links_count": len(internal_links),
                    "external_links_count": len(external_links),
                    "social_media_links": social_media_links,
                    "has_ssl": has_ssl,
                    "word_count": word_count,
                    "response_time_ms": response.elapsed.total_seconds() * 1000
                }
                
                # Website quality contributes to domain power
                website_quality_score = 0
                if has_ssl:
                    website_quality_score += 10  # Has SSL
                if title and len(title) > 10:
                    website_quality_score += 5  # Has good title
                if meta_description and len(meta_description) > 50:
                    website_quality_score += 5  # Has good meta description
                if len(internal_links) > 20:
                    website_quality_score += 5  # Good internal linking
                if len(external_links) > 5:
                    website_quality_score += 5  # Links to other sites
                if len(social_media_links) > 0:
                    website_quality_score += 5  # Has social media presence
                if word_count > 1000:
                    website_quality_score += 5  # Has substantial content
                
                self.results["estimated_domain_power"] += website_quality_score
                
                return True
            else:
                self.results["website_info"] = {"error": f"HTTP Status Code: {response.status_code}"}
                return False
        except Exception as e:
            self.results["website_info"] = {"error": str(e)}
            return False
    
    def find_backlinks(self):
        """Find backlinks using search engine queries"""
        try:
            # Use Google search to find pages linking to the domain
            search_query = f"link:{self.domain} -site:{self.domain}"
            search_url = f"https://www.google.com/search?q={search_query}&num=100"
            
            response = requests.get(search_url, headers=self.headers, timeout=10)
            if response.status_code == 200:
                soup = BeautifulSoup(response.text, 'html.parser')
                
                # Extract search results
                search_results = []
                for result in soup.select("div.g"):
                    link_element = result.select_one("a")
                    if link_element and link_element.get("href"):
                        href = link_element["href"]
                        if href.startswith("/url?q="):
                            href = href.split("/url?q=")[1].split("&")[0]
                        
                        title_element = result.select_one("h3")
                        title = title_element.get_text() if title_element else ""
                        
                        search_results.append({
                            "title": title,
                            "url": href
                        })
                
                self.results["backlinks"] = search_results
                
                # Backlink count contributes to domain power
                backlink_count = len(search_results)
                backlink_factor = min(backlink_count / 100, 1)  # Max factor for 100+ backlinks
                self.results["estimated_domain_power"] += backlink_factor * 30  # Up to 30 points for backlinks
                
                return True
            else:
                self.results["backlinks"] = {"error": f"HTTP Status Code: {response.status_code}"}
                return False
        except Exception as e:
            self.results["backlinks"] = {"error": str(e)}
            return False
    
    def analyze_backlink_domains(self):
        """Analyze the domain power of backlink sources"""
        backlink_domains = []
        
        for backlink in self.results.get("backlinks", []):
            if isinstance(backlink, dict) and "url" in backlink:
                try:
                    parsed_url = urlparse(backlink["url"])
                    domain = parsed_url.netloc
                    
                    # Skip if domain is empty or the same as our target
                    if not domain or domain == self.domain or domain == f"www.{self.domain}":
                        continue
                    
                    # Remove www. prefix if present
                    if domain.startswith("www."):
                        domain = domain[4:]
                    
                    # Check if we already have this domain
                    if any(bd["domain"] == domain for bd in backlink_domains):
                        continue
                    
                    # Create a mini analyzer for this domain
                    mini_analyzer = MiniDomainAnalyzer(domain)
                    domain_power = mini_analyzer.estimate_domain_power()
                    
                    backlink_domains.append({
                        "domain": domain,
                        "url": backlink["url"],
                        "title": backlink.get("title", ""),
                        "estimated_domain_power": domain_power
                    })
                    
                    # Sleep to avoid rate limiting
                    time.sleep(1)
                    
                except Exception as e:
                    print(f"Error analyzing backlink domain: {str(e)}")
        
        # Sort backlink domains by estimated domain power (descending)
        backlink_domains.sort(key=lambda x: x["estimated_domain_power"], reverse=True)
        
        self.results["backlink_domains"] = backlink_domains
        return True
    
    def run_analysis(self):
        """Run all analysis methods"""
        self.analyze_whois()
        self.analyze_dns()
        self.analyze_website()
        self.find_backlinks()
        self.analyze_backlink_domains()
        
        # Normalize the final domain power score to 0-100 scale
        self.results["estimated_domain_power"] = min(round(self.results["estimated_domain_power"]), 100)
        
        return self.results


class MiniDomainAnalyzer:
    """A lightweight domain analyzer for backlink domains"""
    def __init__(self, domain):
        self.domain = domain
        self.url = f"https://{domain}"
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
    
    def estimate_domain_power(self):
        """Estimate domain power based on basic checks"""
        score = 0
        
        # Check if website is accessible
        try:
            response = requests.get(self.url, headers=self.headers, timeout=5)
            if response.status_code == 200:
                score += 20  # Website is accessible
                
                # Check content size
                content_length = len(response.text)
                if content_length > 50000:
                    score += 10  # Substantial content
                
                # Check for SSL
                if self.url.startswith("https://"):
                    score += 10  # Has SSL
                
                # Parse HTML
                soup = BeautifulSoup(response.text, 'html.parser')
                
                # Check for social media links
                social_media_patterns = [
                    "facebook.com", "twitter.com", "instagram.com", 
                    "linkedin.com", "youtube.com", "pinterest.com"
                ]
                
                for link in soup.find_all('a', href=True):
                    href = link['href']
                    for pattern in social_media_patterns:
                        if pattern in href:
                            score += 5  # Has social media presence
                            break
                
                # Count links
                links = soup.find_all('a', href=True)
                if len(links) > 50:
                    score += 10  # Many links
        except:
            # Website not accessible
            pass
        
        # Check domain age
        try:
            w = whois.whois(self.domain)
            if w.creation_date:
                creation_date = w.creation_date[0] if isinstance(w.creation_date, list) else w.creation_date
                if creation_date:
                    domain_age_days = (datetime.datetime.now() - creation_date).days
                    age_factor = min(domain_age_days / 3650, 1)  # Max factor for domains 10+ years old
                    score += age_factor * 20  # Up to 20 points for age
        except:
            # WHOIS lookup failed
            pass
        
        # Check for MX records (email setup)
        try:
            mx_records = dns.resolver.resolve(self.domain, 'MX')
            if mx_records:
                score += 5  # Has email setup
        except:
            # MX lookup failed
            pass
        
        # Normalize score to 0-100
        ret<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>