clapp-pm 1.0.0__py3-none-any.whl

dependency_resolver.py

@@ -0,0 +1,272 @@
+import os
+from package_registry import get_manifest, app_exists
+
+def check_dependencies(manifest):
+    """
+    Manifest'te belirtilen bağımlılıkları kontrol eder.
+    
+    Args:
+        manifest (dict): Kontrol edilecek manifest
+        
+    Returns:
+        list: Eksik bağımlılıkların listesi
+    """
+    missing_dependencies = []
+    
+    # Bağımlılık listesini al
+    dependencies = manifest.get('dependencies', [])
+    
+    if not dependencies:
+        return missing_dependencies
+    
+    # Her bağımlılığı kontrol et
+    for dependency in dependencies:
+        if not app_exists(dependency):
+            missing_dependencies.append(dependency)
+    
+    return missing_dependencies
+
+def check_app_dependencies(app_name):
+    """
+    Belirtilen uygulamanın bağımlılıklarını kontrol eder.
+    
+    Args:
+        app_name (str): Kontrol edilecek uygulama adı
+        
+    Returns:
+        tuple: (missing_dependencies: list, dependency_info: dict)
+    """
+    # Uygulama manifest'ini al
+    manifest = get_manifest(app_name)
+    
+    if not manifest:
+        return [], {"error": f"Uygulama '{app_name}' bulunamadı"}
+    
+    # Bağımlılıkları kontrol et
+    missing_dependencies = check_dependencies(manifest)
+    
+    # Bağımlılık bilgilerini topla
+    dependency_info = {
+        "app_name": app_name,
+        "total_dependencies": len(manifest.get('dependencies', [])),
+        "missing_count": len(missing_dependencies),
+        "satisfied_count": len(manifest.get('dependencies', [])) - len(missing_dependencies),
+        "dependencies": manifest.get('dependencies', []),
+        "missing_dependencies": missing_dependencies
+    }
+    
+    return missing_dependencies, dependency_info
+
+def get_dependency_tree(app_name, visited=None):
+    """
+    Uygulamanın bağımlılık ağacını oluşturur.
+    
+    Args:
+        app_name (str): Uygulama adı
+        visited (set): Ziyaret edilen uygulamalar (döngüsel bağımlılık kontrolü için)
+        
+    Returns:
+        dict: Bağımlılık ağacı
+    """
+    if visited is None:
+        visited = set()
+    
+    # Döngüsel bağımlılık kontrolü
+    if app_name in visited:
+        return {"error": f"Döngüsel bağımlılık tespit edildi: {app_name}"}
+    
+    visited.add(app_name)
+    
+    # Uygulama manifest'ini al
+    manifest = get_manifest(app_name)
+    
+    if not manifest:
+        return {"error": f"Uygulama '{app_name}' bulunamadı"}
+    
+    # Bağımlılık ağacını oluştur
+    tree = {
+        "name": app_name,
+        "version": manifest.get('version', '0.0.0'),
+        "language": manifest.get('language', 'unknown'),
+        "dependencies": [],
+        "missing_dependencies": []
+    }
+    
+    dependencies = manifest.get('dependencies', [])
+    
+    for dep in dependencies:
+        if app_exists(dep):
+            # Bağımlılığın kendi ağacını al
+            dep_tree = get_dependency_tree(dep, visited.copy())
+            tree["dependencies"].append(dep_tree)
+        else:
+            tree["missing_dependencies"].append(dep)
+    
+    return tree
+
+def resolve_all_dependencies(app_name):
+    """
+    Uygulamanın tüm bağımlılıklarını çözümler (derin analiz).
+    
+    Args:
+        app_name (str): Uygulama adı
+        
+    Returns:
+        dict: Çözümleme sonuçları
+    """
+    result = {
+        "app_name": app_name,
+        "status": "unknown",
+        "all_dependencies": set(),
+        "missing_dependencies": set(),
+        "dependency_tree": None,
+        "circular_dependencies": [],
+        "resolution_order": []
+    }
+    
+    # Bağımlılık ağacını al
+    tree = get_dependency_tree(app_name)
+    result["dependency_tree"] = tree
+    
+    if "error" in tree:
+        result["status"] = "error"
+        return result
+    
+    # Tüm bağımlılıkları topla
+    def collect_dependencies(node, all_deps, missing_deps):
+        if "dependencies" in node:
+            for dep in node["dependencies"]:
+                all_deps.add(dep["name"])
+                collect_dependencies(dep, all_deps, missing_deps)
+        
+        if "missing_dependencies" in node:
+            for missing in node["missing_dependencies"]:
+                missing_deps.add(missing)
+    
+    collect_dependencies(tree, result["all_dependencies"], result["missing_dependencies"])
+    
+    # Durum belirleme
+    if result["missing_dependencies"]:
+        result["status"] = "missing_dependencies"
+    else:
+        result["status"] = "resolved"
+    
+    # Çözümleme sırası (topological sort benzeri)
+    result["resolution_order"] = list(result["all_dependencies"])
+    
+    return result
+
+def get_dependency_report(app_name):
+    """
+    Bağımlılık raporu oluşturur.
+    
+    Args:
+        app_name (str): Uygulama adı
+        
+    Returns:
+        str: Formatlanmış bağımlılık raporu
+    """
+    missing_deps, dep_info = check_app_dependencies(app_name)
+    
+    if "error" in dep_info:
+        return f"❌ Hata: {dep_info['error']}"
+    
+    report = f"📦 {app_name} Bağımlılık Raporu\n"
+    report += "=" * 40 + "\n"
+    
+    if dep_info["total_dependencies"] == 0:
+        report += "✅ Bu uygulama hiçbir bağımlılığa sahip değil.\n"
+        return report
+    
+    report += f"📊 Toplam Bağımlılık: {dep_info['total_dependencies']}\n"
+    report += f"✅ Karşılanan: {dep_info['satisfied_count']}\n"
+    report += f"❌ Eksik: {dep_info['missing_count']}\n\n"
+    
+    if missing_deps:
+        report += "🚨 Eksik Bağımlılıklar:\n"
+        for dep in missing_deps:
+            report += f"  - {dep}\n"
+        report += "\n"
+    
+    if dep_info["satisfied_count"] > 0:
+        satisfied_deps = [dep for dep in dep_info["dependencies"] if dep not in missing_deps]
+        report += "✅ Karşılanan Bağımlılıklar:\n"
+        for dep in satisfied_deps:
+            dep_manifest = get_manifest(dep)
+            version = dep_manifest.get('version', '0.0.0') if dep_manifest else 'bilinmiyor'
+            report += f"  - {dep} (v{version})\n"
+        report += "\n"
+    
+    return report
+
+def check_system_dependencies():
+    """
+    Sistemdeki tüm uygulamaların bağımlılıklarını kontrol eder.
+    
+    Returns:
+        dict: Sistem geneli bağımlılık durumu
+    """
+    from package_registry import list_packages
+    
+    packages = list_packages()
+    system_report = {
+        "total_apps": len(packages),
+        "apps_with_dependencies": 0,
+        "apps_with_missing_dependencies": 0,
+        "total_dependencies": 0,
+        "total_missing": 0,
+        "problematic_apps": []
+    }
+    
+    for package in packages:
+        app_name = package['name']
+        missing_deps, dep_info = check_app_dependencies(app_name)
+        
+        if dep_info["total_dependencies"] > 0:
+            system_report["apps_with_dependencies"] += 1
+            system_report["total_dependencies"] += dep_info["total_dependencies"]
+        
+        if missing_deps:
+            system_report["apps_with_missing_dependencies"] += 1
+            system_report["total_missing"] += len(missing_deps)
+            system_report["problematic_apps"].append({
+                "name": app_name,
+                "missing_dependencies": missing_deps
+            })
+    
+    return system_report
+
+def get_system_dependency_report():
+    """
+    Sistem geneli bağımlılık raporu oluşturur.
+    
+    Returns:
+        str: Formatlanmış sistem raporu
+    """
+    report_data = check_system_dependencies()
+    
+    report = "🏢 Sistem Bağımlılık Raporu\n"
+    report += "=" * 40 + "\n"
+    
+    report += f"📱 Toplam Uygulama: {report_data['total_apps']}\n"
+    report += f"🔗 Bağımlılığa Sahip: {report_data['apps_with_dependencies']}\n"
+    report += f"⚠️  Eksik Bağımlılığa Sahip: {report_data['apps_with_missing_dependencies']}\n"
+    report += f"📊 Toplam Bağımlılık: {report_data['total_dependencies']}\n"
+    report += f"❌ Toplam Eksik: {report_data['total_missing']}\n\n"
+    
+    if report_data['problematic_apps']:
+        report += "🚨 Sorunlu Uygulamalar:\n"
+        for app in report_data['problematic_apps']:
+            report += f"  📦 {app['name']}:\n"
+            for dep in app['missing_dependencies']:
+                report += f"    - {dep}\n"
+        report += "\n"
+    else:
+        report += "✅ Tüm bağımlılıklar karşılanmış!\n"
+    
+    return report
+
+if __name__ == "__main__":
+    # Test için örnek kullanım
+    print("Sistem bağımlılık raporu:")
+    print(get_system_dependency_report()) 

doctor_command.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""
+doctor_command.py - Kapsamlı sistem tanılaması modülü
+
+Bu modül `clapp doctor` komutunu destekler ve sistemin
+clapp için uygun olup olmadığını kapsamlı şekilde kontrol eder.
+"""
+
+import os
+import sys
+import shutil
+import platform
+import subprocess
+from pathlib import Path
+from check_env import (
+    check_python_version,
+    check_clapp_in_path,
+    check_platform_info,
+    check_python_executable,
+    check_working_directory,
+    check_apps_directory,
+    check_permissions,
+    check_flet_installation
+)
+
+def check_clapp_config():
+    """clapp konfigürasyon dizinini kontrol eder"""
+    home = Path.home()
+    clapp_config_dir = home / ".clapp"
+    
+    if clapp_config_dir.exists():
+        return True, f"Konfigürasyon dizini mevcut: {clapp_config_dir}"
+    else:
+        return False, "Konfigürasyon dizini bulunamadı (~/.clapp)"
+
+def check_path_environment():
+    """PATH ortam değişkenini detaylı kontrol eder"""
+    path_env = os.environ.get("PATH", "")
+    path_dirs = path_env.split(os.pathsep)
+    
+    # Önemli dizinleri kontrol et
+    important_dirs = []
+    
+    # Platform'a göre önemli dizinler
+    system = platform.system().lower()
+    if system == "windows":
+        important_dirs = [
+            os.path.join(os.environ.get("APPDATA", ""), "Python", "Scripts"),
+            os.path.join(sys.prefix, "Scripts"),
+        ]
+    else:
+        home = Path.home()
+        important_dirs = [
+            str(home / ".local" / "bin"),
+            "/usr/local/bin",
+            "/usr/bin",
+        ]
+    
+    found_dirs = []
+    missing_dirs = []
+    
+    for imp_dir in important_dirs:
+        if imp_dir in path_dirs:
+            found_dirs.append(imp_dir)
+        else:
+            missing_dirs.append(imp_dir)
+    
+    if missing_dirs:
+        return False, f"PATH'te eksik dizinler: {', '.join(missing_dirs)}"
+    else:
+        return True, f"PATH uygun ({len(found_dirs)} önemli dizin mevcut)"
+
+def check_dependencies():
+    """Bağımlılıkları kontrol eder"""
+    dependencies = ["python", "pip"]
+    
+    missing = []
+    found = []
+    
+    for dep in dependencies:
+        if shutil.which(dep):
+            found.append(dep)
+        else:
+            missing.append(dep)
+    
+    if missing:
+        return False, f"Eksik bağımlılıklar: {', '.join(missing)}"
+    else:
+        return True, f"Tüm bağımlılıklar mevcut: {', '.join(found)}"
+
+def check_disk_space():
+    """Disk alanını kontrol eder"""
+    try:
+        cwd = Path.cwd()
+        stat = shutil.disk_usage(cwd)
+        
+        # GB'ye çevir
+        free_gb = stat.free / (1024**3)
+        total_gb = stat.total / (1024**3)
+        
+        if free_gb < 0.5:  # 500MB'den az
+            return False, f"Yetersiz disk alanı: {free_gb:.1f}GB boş"
+        else:
+            return True, f"Disk alanı uygun: {free_gb:.1f}GB / {total_gb:.1f}GB"
+    
+    except Exception as e:
+        return False, f"Disk alanı kontrol edilemedi: {str(e)}"
+
+def check_network_access():
+    """Ağ erişimini kontrol eder"""
+    try:
+        # Basit bir ping testi
+        import socket
+        socket.create_connection(("8.8.8.8", 53), timeout=3)
+        return True, "Ağ erişimi mevcut"
+    except:
+        return False, "Ağ erişimi yok veya sınırlı"
+
+def check_installed_apps():
+    """Yüklü uygulamaları kontrol eder"""
+    try:
+        from package_registry import list_packages
+        packages = list_packages()
+        
+        if not packages:
+            return True, "Yüklü uygulama yok (normal)"
+        
+        # Bozuk uygulamaları kontrol et
+        broken_apps = []
+        for package in packages:
+            if not package.get("name") or not package.get("entry"):
+                broken_apps.append(package.get("name", "Bilinmiyor"))
+        
+        if broken_apps:
+            return False, f"Bozuk uygulamalar: {', '.join(broken_apps)}"
+        else:
+            return True, f"{len(packages)} uygulama yüklü (tümü geçerli)"
+    
+    except Exception as e:
+        return False, f"Uygulama listesi kontrol edilemedi: {str(e)}"
+
+def check_python_modules():
+    """Gerekli Python modüllerini kontrol eder"""
+    required_modules = [
+        ("json", "JSON desteği"),
+        ("os", "İşletim sistemi arayüzü"),
+        ("sys", "Sistem arayüzü"),
+        ("pathlib", "Dosya yolu işlemleri"),
+        ("subprocess", "Alt süreç yönetimi"),
+        ("argparse", "Komut satırı ayrıştırma"),
+    ]
+    
+    missing = []
+    found = []
+    
+    for module_name, description in required_modules:
+        try:
+            __import__(module_name)
+            found.append(module_name)
+        except ImportError:
+            missing.append(f"{module_name} ({description})")
+    
+    if missing:
+        return False, f"Eksik Python modülleri: {', '.join(missing)}"
+    else:
+        return True, f"Tüm gerekli modüller mevcut ({len(found)} modül)"
+
+def run_doctor():
+    """Kapsamlı sistem tanılaması yapar"""
+    print("🩺 clapp Sistem Tanılaması")
+    print("=" * 60)
+    print("Sisteminiz clapp için uygun mu kontrol ediliyor...")
+    print()
+    
+    # Tüm kontroller
+    checks = [
+        ("Python Sürümü", check_python_version),
+        ("Platform Bilgisi", check_platform_info),
+        ("Python Çalıştırılabilir", check_python_executable),
+        ("Çalışma Dizini", check_working_directory),
+        ("clapp PATH Kontrolü", check_clapp_in_path),
+        ("PATH Ortam Değişkeni", check_path_environment),
+        ("Sistem Bağımlılıkları", check_dependencies),
+        ("Python Modülleri", check_python_modules),
+        ("apps/ Dizini", check_apps_directory),
+        ("Yüklü Uygulamalar", check_installed_apps),
+        ("Yazma İzinleri", check_permissions),
+        ("Disk Alanı", check_disk_space),
+        ("Ağ Erişimi", check_network_access),
+        ("Flet Kurulumu", check_flet_installation),
+        ("clapp Konfigürasyonu", check_clapp_config),
+    ]
+    
+    passed = 0
+    failed = 0
+    warnings = 0
+    
+    results = []
+    
+    for check_name, check_func in checks:
+        try:
+            success, message = check_func()
+            results.append((check_name, success, message))
+            
+            if success:
+                print(f"✅ {check_name}: {message}")
+                passed += 1
+            else:
+                print(f"❌ {check_name}: {message}")
+                failed += 1
+        except Exception as e:
+            error_msg = f"Hata - {str(e)}"
+            results.append((check_name, False, error_msg))
+            print(f"⚠️  {check_name}: {error_msg}")
+            warnings += 1
+    
+    # Özet
+    print("\n" + "=" * 60)
+    print("📊 Tanılama Özeti:")
+    print(f"✅ Başarılı: {passed}")
+    print(f"❌ Başarısız: {failed}")
+    print(f"⚠️  Uyarı: {warnings}")
+    
+    # Genel durum
+    if failed == 0 and warnings == 0:
+        print("\n🎉 Mükemmel! Sisteminiz clapp için tamamen hazır.")
+        print("✨ Herhangi bir sorun bulunmadı.")
+    elif failed == 0:
+        print("\n✅ İyi! Sisteminiz clapp için genel olarak uygun.")
+        print("⚠️  Bazı küçük uyarılar var, ancak çalışmaya engel değil.")
+    else:
+        print("\n🔧 Dikkat! Bazı sorunlar bulundu.")
+        print("❌ Aşağıdaki sorunları çözmeniz önerilir:")
+    
+    # Detaylı öneriler
+    if failed > 0:
+        print("\n💡 Çözüm Önerileri:")
+        
+        for check_name, success, message in results:
+            if not success:
+                print(f"\n🔧 {check_name}:")
+                print(f"   Sorun: {message}")
+                
+                # Spesifik öneriler
+                if "Python" in check_name and "sürüm" in message.lower():
+                    print("   Çözüm: Python 3.8 veya daha yeni sürüm yükleyin")
+                elif "PATH" in check_name:
+                    print("   Çözüm: Python Scripts dizinini PATH'e ekleyin")
+                    print("   Detay: clapp check-env komutunu çalıştırın")
+                elif "apps/" in check_name:
+                    print("   Çözüm: mkdir apps komutu ile apps dizini oluşturun")
+                elif "Flet" in check_name:
+                    print("   Çözüm: pip install flet komutu ile Flet'i yükleyin")
+                elif "izin" in message.lower():
+                    print("   Çözüm: Dizin izinlerini kontrol edin veya farklı dizinde çalıştırın")
+                elif "disk" in message.lower():
+                    print("   Çözüm: Disk alanı açın veya farklı dizinde çalıştırın")
+                elif "ağ" in message.lower():
+                    print("   Çözüm: İnternet bağlantınızı kontrol edin")
+    
+    # Sonraki adımlar
+    print("\n🚀 Sonraki Adımlar:")
+    if failed == 0:
+        print("• clapp list - Yüklü uygulamaları listeleyin")
+        print("• clapp gui - Grafik arayüzü başlatın")
+        print("• clapp --help - Tüm komutları görün")
+    else:
+        print("• Yukarıdaki sorunları çözün")
+        print("• clapp doctor - Tekrar tanılama çalıştırın")
+        print("• clapp check-env - Temel kontrolleri yapın")
+    
+    print("\n📞 Yardım:")
+    print("• GitHub: https://github.com/user/clapp")
+    print("• Dokümantasyon: README.md dosyasını okuyun")
+    
+    return failed == 0
+
+if __name__ == "__main__":
+    run_doctor()