Update app.py

app.py

@@ -1,272 +1,114 @@
 import streamlit as st
-from streamlit_lottie import st_lottie
-from streamlit_option_menu import option_menu
 import requests
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from datetime import datetime
-import httpx
-import asyncio
-import aiohttp
-from bs4 import BeautifulSoup
 import whois
-import ssl
 import socket
-import dns.resolver
-from urllib.parse import urlparse, urljoin
-import json
-import numpy as np
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from webdriver_manager.chrome import ChromeDriverManager
-from PIL import Image
-import io
-import time
-import tldextract
-import requests_html
-from fake_useragent import UserAgent
-from concurrent.futures import ThreadPoolExecutor
-import re
-from urllib.robotparser import RobotFileParser
-import random
-from textblob import TextBlob
-from collections import Counter
-import networkx as nx
-
-# تهيئة المتغيرات العامة
-TIMEOUT = 10
-MAX_RETRIES = 3
-COMMON_CRAWL_INDEX = 'https://index.commoncrawl.org/CC-MAIN-2023-50-index'
-
-class WebsiteAnalyzer:
-    def __init__(self):
-        self.ua = UserAgent()
-        self.session = requests.Session()
-        self.cache = {}
-        
-    def _get_headers(self):
-        return {
-            'User-Agent': self.ua.random,
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Connection': 'keep-alive',
-        }
-
-    async def _fetch_with_retry(self, url, retries=MAX_RETRIES):
-        for i in range(retries):
-            try:
-                async with httpx.AsyncClient(timeout=TIMEOUT) as client:
-                    response = await client.get(url, headers=self._get_headers())
-                    response.raise_for_status()
-                    return response
-            except Exception as e:
-                if i == retries - 1:
-                    raise e
-                await asyncio.sleep(1)
-
-    async def analyze_performance(self, url):
-        try:
-            performance_metrics = {
-                'dns_lookup': [],
-                'tcp_handshake': [],
-                'ttfb': [],
-                'content_download': []
-            }
-
-            # تحليل الأداء على أجهزة مختلفة
-            devices = ['desktop', 'mobile', 'tablet']
-            device_metrics = {}
-            
-            for device in devices:
-                chrome_options = Options()
-                chrome_options.add_argument(f"--user-agent={self._get_device_user_agent(device)}")
-                start_time = time.time()
-                
-                # قياس الأداء لكل جهاز
-                device_metrics[device] = {
-                    'load_time': time.time() - start_time,
-                    'render_time': self._measure_render_time(url, chrome_options)
-                }
-
-            # تحليل عام للأداء
-            for _ in range(3):
-                start_time = time.time()
-                domain = urlparse(url).netloc
-                dns_start = time.time()
-                socket.gethostbyname(domain)
-                performance_metrics['dns_lookup'].append(time.time() - dns_start)
-
-                response = await self._fetch_with_retry(url)
-                performance_metrics['ttfb'].append(response.elapsed.total_seconds())
-                performance_metrics['content_download'].append(time.time() - start_time - response.elapsed.total_seconds())
-
-            # تحليل الموارد والتحسينات
-            soup = BeautifulSoup(response.text, 'html.parser')
-            resource_analysis = self._analyze_resources(soup, response.content)
-            optimization_suggestions = self._generate_optimization_suggestions(resource_analysis)
-
-            return {
-                "أداء الموقع": {
-                    "تحليل الأجهزة": {
-                        device: {
-                            "زمن التحميل": f"{metrics['load_time']:.2f} ثانية",
-                            "زمن العرض": f"{metrics['render_time']:.2f} ثانية"
-                        } for device, metrics in device_metrics.items()
-                    },
-                    "تحليل الموارد": resource_analysis,
-                    "اقتراحات التحسين": optimization_suggestions
-                }
-            }
-        except Exception as e:
-            return {"error": f"حدث خطأ أثناء تحليل الأداء: {str(e)}"}
-
-    def _analyze_resources(self, soup, content):
-        """تحليل موارد الصفحة وتحديد فرص التحسين"""
-        resources = {
-            'images': self._analyze_images(soup),
-            'scripts': self._analyze_scripts(soup),
-            'styles': self._analyze_styles(soup),
-            'fonts': self._analyze_fonts(soup),
-            'total_size': len(content) / 1024
-        }
-        return resources
-
-    def _analyze_images(self, soup):
-        """تحليل تفصيلي للصور"""
-        images = soup.find_all('img')
-        return {
-            'count': len(images),
-            'without_alt': len([img for img in images if not img.get('alt')]),
-            'large_images': len([img for img in images if self._is_large_image(img)]),
-            'optimization_needed': self._check_image_optimization(images)
-        }
-
-    def _analyze_competitors(self, url):
-        """تحليل المنافسين والمقارنة معهم"""
-        try:
-            competitors = self._find_competitors(url)
-            comparison = {}
-            
-            for competitor in competitors:
-                comparison[competitor] = {
-                    'traffic': self._estimate_traffic(competitor),
-                    'keywords': self._analyze_keywords(competitor),
-                    'backlinks': self._analyze_backlinks(competitor),
-                    'social_presence': self._analyze_social_presence(competitor)
-                }
-            
-            return {
-                'المنافسون الرئيسيون': comparison,
-                'تحليل مقارن': self._generate_competitive_analysis(comparison)
-            }
-        except Exception as e:
-            return {"error": f"خطأ في تحليل المنافسين: {str(e)}"}
-
-    def _analyze_content_quality(self, soup):
-        """تحليل جودة المحتوى"""
-        text_content = soup.get_text()
-        
-        # تحليل لغوي
-        blob = TextBlob(text_content)
-        
-        # تحليل القراءة
-        readability = self._calculate_readability(text_content)
-        
-        # تحليل الكلمات المفتاحية
-        keywords = self._extract_keywords(text_content)
-        
-        return {
-            "تحليل المحتوى": {
-                "مستوى القراءة": readability,
-                "تنوع المفردات": self._calculate_lexical_diversity(text_content),
-                "الكلمات المفتاحية الرئيسية": keywords[:10],
-                "العاطفة": {
-                    "إيجابية": blob.sentiment.polarity,
-                    "موضوعية": blob.sentiment.subjectivity
-                }
-            }
-        }
-
-    def _analyze_backlinks(self, url):
-        """تحليل الروابط الخلفية"""
-        try:
-            backlinks = self._fetch_backlinks(url)
-            
-            # تحليل جودة الروابط
-            quality_metrics = self._analyze_backlink_quality(backlinks)
-            
-            # تحليل تنوع المصادر
-            diversity = self._analyze_source_diversity(backlinks)
-            
-            return {
-                "تحليل الروابط الخلفية": {
-                    "العدد الإجمالي": len(backlinks),
-                    "جودة الروابط": quality_metrics,
-                    "تنوع المصادر": diversity,
-                    "أهم المصادر": self._get_top_referring_domains(backlinks)
-                }
-            }
-        except Exception as e:
-            return {"error": f"خطأ في تحليل الروابط الخلفية: {str(e)}"}
-
-    def _analyze_social_signals(self, url):
-        """تحليل الإشارات الاجتماعية"""
-        try:
-            social_metrics = {
-                'facebook': self._get_facebook_shares(url),
-                'twitter': self._get_twitter_shares(url),
-                'linkedin': self._get_linkedin_shares(url),
-                'pinterest': self._get_pinterest_shares(url)
-            }
-            
-            engagement_analysis = self._analyze_social_engagement(social_metrics)
-            
-            return {
-                "التواجد الاجتماعي": {
-                    "إحصائيات المشاركة": social_metrics,
-                    "تحليل التفاعل": engagement_analysis,
-                    "توصيات": self._generate_social_recommendations(engagement_analysis)
-                }
-            }
-        except Exception as e:
-            return {"error": f"خطأ في تحليل الإشارات الاجتماعية: {str(e)}"}
-
-    def _generate_comprehensive_report(self, url):
-        """توليد تقرير شامل"""
-        try:
-            report = {
-                "تحليل الأداء": self.analyze_performance(url),
-                "تحليل SEO": self.analyze_seo(url),
-                "تحليل الأمان": self.analyze_security(url),
-                "تحليل المنافسين": self._analyze_competitors(url),
-                "تحليل المحتوى": self._analyze_content_quality(BeautifulSoup(requests.get(url).text, 'html.parser')),
-                "تحليل الروابط": self._analyze_backlinks(url),
-                "التواجد الاجتماعي": self._analyze_social_signals(url),
-                "التو��يات": self._generate_recommendations()
-            }
-            
-            return report
-        except Exception as e:
-            return {"error": f"خطأ في توليد التقرير الشامل: {str(e)}"}
-
-    def _generate_recommendations(self):
-        """توليد توصيات مخصصة"""
-        recommendations = {
-            "تحسينات عاجلة": [],
-            "تحسينات متوسطة الأولوية": [],
-            "تحسينات طويلة المدى": []
-        }
-        
-        # إضافة التوصيات بناءً على نتائج التحليل
-        return recommendations
+import ssl
+from bs4 import BeautifulSoup
+from datetime import datetime
 
-# مثال للاستخدام
-async def main():
-    analyzer = WebsiteAnalyzer()
-    url = "https://example.com"
-    report = await analyzer._generate_comprehensive_report(url)
-    print(json.dumps(report, ensure_ascii=False, indent=2))
+def get_ssl_expiry_date(hostname):
+  try:
+      context = ssl.create_default_context()
+      with socket.create_connection((hostname, 443)) as sock:
+          with context.wrap_socket(sock, server_hostname=hostname) as ssock:
+              ssl_info = ssock.getpeercert()
+              expire_date = datetime.strptime(ssl_info['notAfter'], '%b %d %H:%M:%S %Y %Z')
+              days_left = (expire_date - datetime.utcnow()).days
+              return days_left
+  except Exception as e:
+      return None
+
+def main():
+  st.title("Website Analysis Tool")
+
+  url = st.text_input("Enter the website URL (e.g., https://www.example.com)")
+
+  if st.button("Analyze") and url:
+      if not url.startswith("http"):
+          url = "http://" + url
+
+      try:
+          response = requests.get(url)
+          status_code = response.status_code
+
+          # Basic SEO Analysis
+          soup = BeautifulSoup(response.content, 'html.parser')
+          title = soup.title.string if soup.title else "No title tag found"
+          meta_desc = soup.find('meta', attrs={'name': 'description'})
+          meta_desc_content = meta_desc['content'] if meta_desc else "No meta description found"
+
+          # WHOIS Information
+          domain = url.replace("http://", "").replace("https://", "").split('/')[0]
+          domain_info = whois.whois(domain)
+
+          # SSL Certificate Check
+          ssl_days_left = get_ssl_expiry_date(domain)
+          if ssl_days_left is not None:
+              ssl_status = f"SSL Certificate expires in {ssl_days_left} days"
+          else:
+              ssl_status = "No SSL Certificate found"
+
+          # Security Headers Check
+          security_score = 0
+          headers = response.headers
+
+          if 'X-Frame-Options' in headers:
+              security_score += 10
+          if 'X-Content-Type-Options' in headers:
+              security_score += 10
+          if 'Content-Security-Policy' in headers:
+              security_score += 10
+          if 'Strict-Transport-Security' in headers:
+              security_score += 10
+          if 'Referrer-Policy' in headers:
+              security_score += 10
+
+          # Overall Score Calculation
+          total_score = security_score
+          if title != "No title tag found":
+              total_score += 20
+          if meta_desc_content != "No meta description found":
+              total_score += 20
+          if ssl_days_left is not None:
+              total_score += 20
+
+          st.subheader("SEO Analysis")
+          st.write(f"**Title Tag:** {title}")
+          st.write(f"**Meta Description:** {meta_desc_content}")
+
+          st.subheader("Security Analysis")
+          st.write(f"**SSL Status:** {ssl_status}")
+          st.write("**Security Headers:**")
+          for header in ['X-Frame-Options', 'X-Content-Type-Options', 'Content-Security-Policy',
+                         'Strict-Transport-Security', 'Referrer-Policy']:
+              if header in headers:
+                  st.write(f"- {header}: {headers[header]}")
+              else:
+                  st.write(f"- {header}: Not Found")
+
+          st.subheader("WHOIS Information")
+          st.write(f"**Domain Name:** {domain_info.domain_name}")
+          st.write(f"**Registrar:** {domain_info.registrar}")
+          st.write(f"**Creation Date:** {domain_info.creation_date}")
+          st.write(f"**Expiration Date:** {domain_info.expiration_date}")
+
+          st.subheader("Overall Score")
+          st.write(f"**Total Score:** {total_score} / 100")
+
+          st.subheader("Suggestions for Improvement")
+          if title == "No title tag found":
+              st.write("- Add a title tag to your homepage.")
+          if meta_desc_content == "No meta description found":
+              st.write("- Add a meta description to your homepage.")
+          if ssl_days_left is None:
+              st.write("- Install an SSL certificate to secure your site with HTTPS.")
+          for header in ['X-Frame-Options', 'X-Content-Type-Options', 'Content-Security-Policy',
+                         'Strict-Transport-Security', 'Referrer-Policy']:
+              if header not in headers:
+                  st.write(f"- Add the {header} header to improve security.")
+
+      except Exception as e:
+          st.error(f"An error occurred: {e}")
 
 if __name__ == "__main__":
-    asyncio.run(main())
+  main()