clapp-pm 1.0.0__py3-none-any.whl

remote_registry.py

@@ -0,0 +1,285 @@
+import json
+import urllib.request
+import urllib.parse
+from typing import List, Dict, Optional
+
+# Uzak paket deposu URL'si
+REMOTE_PACKAGES_URL = "https://raw.githubusercontent.com/mburakmmm/clapp-packages/main/packages.json"
+
+def fetch_remote_packages() -> List[Dict]:
+    """
+    Uzak paket deposundan paket listesini indirir.
+    
+    Returns:
+        list: Paket listesi (dict formatında)
+    """
+    try:
+        print("Uzak paket deposu kontrol ediliyor...")
+        
+        # HTTP isteği gönder
+        with urllib.request.urlopen(REMOTE_PACKAGES_URL) as response:
+            data = response.read().decode('utf-8')
+        
+        # JSON'u parse et
+        packages = json.loads(data)
+        
+        print(f"✅ {len(packages)} paket bulundu")
+        return packages
+        
+    except urllib.error.URLError as e:
+        print(f"❌ Ağ hatası: {e}")
+        return []
+    except json.JSONDecodeError as e:
+        print(f"❌ JSON parse hatası: {e}")
+        return []
+    except Exception as e:
+        print(f"❌ Beklenmeyen hata: {e}")
+        return []
+
+def get_package_info(app_name: str) -> Optional[Dict]:
+    """
+    Belirtilen uygulama için uzak paket bilgilerini döndürür.
+    
+    Args:
+        app_name (str): Uygulama adı
+        
+    Returns:
+        dict or None: Paket bilgileri veya None
+    """
+    packages = fetch_remote_packages()
+    
+    for package in packages:
+        if package.get('name') == app_name:
+            return package
+    
+    return None
+
+def search_packages(query: str) -> List[Dict]:
+    """
+    Paket deposunda arama yapar.
+    
+    Args:
+        query (str): Arama terimi
+        
+    Returns:
+        list: Eşleşen paketler
+    """
+    packages = fetch_remote_packages()
+    results = []
+    
+    query_lower = query.lower()
+    
+    for package in packages:
+        # İsim, açıklama ve dilde arama yap
+        name = package.get('name', '').lower()
+        description = package.get('description', '').lower()
+        language = package.get('language', '').lower()
+        
+        if (query_lower in name or 
+            query_lower in description or 
+            query_lower in language):
+            results.append(package)
+    
+    return results
+
+def get_packages_by_language(language: str) -> List[Dict]:
+    """
+    Belirtilen dildeki paketleri döndürür.
+    
+    Args:
+        language (str): Programlama dili
+        
+    Returns:
+        list: Belirtilen dildeki paketler
+    """
+    packages = fetch_remote_packages()
+    filtered_packages = []
+    
+    for package in packages:
+        if package.get('language', '').lower() == language.lower():
+            filtered_packages.append(package)
+    
+    return filtered_packages
+
+def list_remote_packages(show_details=False) -> str:
+    """
+    Uzak paket deposundaki paketleri listeler.
+    
+    Args:
+        show_details (bool): Detayları göster
+        
+    Returns:
+        str: Formatlanmış paket listesi
+    """
+    packages = fetch_remote_packages()
+    
+    if not packages:
+        return "❌ Uzak paket deposuna erişilemedi veya paket bulunamadı"
+    
+    output = f"🌐 Uzak Paket Deposu ({len(packages)} paket)\n"
+    output += "=" * 50 + "\n"
+    
+    # Dillere göre grupla
+    by_language = {}
+    for package in packages:
+        language = package.get('language', 'unknown')
+        if language not in by_language:
+            by_language[language] = []
+        by_language[language].append(package)
+    
+    for language, lang_packages in sorted(by_language.items()):
+        output += f"\n📚 {language.upper()} ({len(lang_packages)} paket):\n"
+        
+        for package in sorted(lang_packages, key=lambda x: x.get('name', '')):
+            name = package.get('name', 'Bilinmiyor')
+            version = package.get('version', '0.0.0')
+            description = package.get('description', 'Açıklama yok')
+            
+            output += f"  📦 {name} (v{version})\n"
+            
+            if show_details:
+                output += f"      Açıklama: {description}\n"
+                output += f"      İndirme: {package.get('download_url', 'Yok')}\n"
+                
+                if package.get('dependencies'):
+                    deps = ', '.join(package['dependencies'])
+                    output += f"      Bağımlılıklar: {deps}\n"
+    
+    return output
+
+def validate_package_url(url: str) -> bool:
+    """
+    Paket URL'sinin geçerli olup olmadığını kontrol eder.
+    
+    Args:
+        url (str): Kontrol edilecek URL
+        
+    Returns:
+        bool: Geçerliyse True
+    """
+    try:
+        # URL formatını kontrol et
+        parsed = urllib.parse.urlparse(url)
+        if not parsed.scheme or not parsed.netloc:
+            return False
+        
+        # HTTP HEAD isteği gönder
+        request = urllib.request.Request(url, method='HEAD')
+        with urllib.request.urlopen(request) as response:
+            return response.status == 200
+            
+    except Exception:
+        return False
+
+def get_package_statistics() -> Dict:
+    """
+    Paket deposu istatistiklerini döndürür.
+    
+    Returns:
+        dict: İstatistik bilgileri
+    """
+    packages = fetch_remote_packages()
+    
+    stats = {
+        "total_packages": len(packages),
+        "languages": {},
+        "with_dependencies": 0,
+        "without_dependencies": 0,
+        "total_dependencies": 0
+    }
+    
+    for package in packages:
+        # Dil istatistikleri
+        language = package.get('language', 'unknown')
+        stats["languages"][language] = stats["languages"].get(language, 0) + 1
+        
+        # Bağımlılık istatistikleri
+        dependencies = package.get('dependencies', [])
+        if dependencies:
+            stats["with_dependencies"] += 1
+            stats["total_dependencies"] += len(dependencies)
+        else:
+            stats["without_dependencies"] += 1
+    
+    return stats
+
+def get_statistics_report() -> str:
+    """
+    İstatistik raporunu döndürür.
+    
+    Returns:
+        str: Formatlanmış istatistik raporu
+    """
+    stats = get_package_statistics()
+    
+    if stats["total_packages"] == 0:
+        return "❌ Paket deposu verisi alınamadı"
+    
+    report = "📊 Paket Deposu İstatistikleri\n"
+    report += "=" * 40 + "\n"
+    
+    report += f"📦 Toplam Paket: {stats['total_packages']}\n"
+    report += f"🔗 Bağımlılığa Sahip: {stats['with_dependencies']}\n"
+    report += f"🆓 Bağımlılıksız: {stats['without_dependencies']}\n"
+    report += f"📊 Toplam Bağımlılık: {stats['total_dependencies']}\n\n"
+    
+    # Dil dağılımı
+    report += "💻 Dil Dağılımı:\n"
+    for language, count in sorted(stats["languages"].items()):
+        percentage = (count / stats["total_packages"]) * 100
+        report += f"  {language}: {count} paket (%{percentage:.1f})\n"
+    
+    return report
+
+def check_remote_connectivity() -> bool:
+    """
+    Uzak paket deposuna bağlantıyı kontrol eder.
+    
+    Returns:
+        bool: Bağlantı varsa True
+    """
+    try:
+        request = urllib.request.Request(REMOTE_PACKAGES_URL, method='HEAD')
+        with urllib.request.urlopen(request, timeout=5) as response:
+            return response.status == 200
+    except Exception:
+        return False
+
+def get_package_versions(app_name: str) -> List[str]:
+    """
+    Paketin mevcut sürümlerini döndürür (şu an sadece mevcut sürüm).
+    
+    Args:
+        app_name (str): Uygulama adı
+        
+    Returns:
+        list: Sürüm listesi
+    """
+    package = get_package_info(app_name)
+    
+    if package:
+        return [package.get('version', '0.0.0')]
+    
+    return []
+
+if __name__ == "__main__":
+    # Test için örnek kullanım
+    print("Remote Registry Test")
+    print("=" * 30)
+    
+    # Bağlantı testi
+    if check_remote_connectivity():
+        print("✅ Uzak paket deposuna bağlantı başarılı")
+        
+        # Paket listesi
+        print("\nPaket listesi:")
+        print(list_remote_packages())
+        
+        # İstatistikler
+        print("\nİstatistikler:")
+        print(get_statistics_report())
+        
+    else:
+        print("❌ Uzak paket deposuna bağlantı kurulamadı")
+    
+    print("\nTest tamamlandı.") 

validate_command.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""
+validate_command.py - Uygulama doğrulama modülü
+
+Bu modül `clapp validate <folder>` komutunu destekler ve
+uygulama klasörlerinin doğru yapıda olup olmadığını kontrol eder.
+"""
+
+import os
+import json
+from pathlib import Path
+from manifest_validator import validate_manifest_verbose
+
+def validate_app_folder(folder_path):
+    """Uygulama klasörünü doğrular"""
+    folder = Path(folder_path)
+    
+    print(f"🔍 '{folder_path}' klasörü doğrulanıyor...")
+    print("=" * 50)
+    
+    # Klasörün var olup olmadığını kontrol et
+    if not folder.exists():
+        print(f"❌ Klasör bulunamadı: {folder_path}")
+        return False
+    
+    if not folder.is_dir():
+        print(f"❌ Belirtilen yol bir klasör değil: {folder_path}")
+        return False
+    
+    errors = []
+    warnings = []
+    
+    # 1. manifest.json kontrolü
+    manifest_path = folder / "manifest.json"
+    if not manifest_path.exists():
+        errors.append("manifest.json dosyası bulunamadı")
+    else:
+        print("✅ manifest.json dosyası mevcut")
+        
+        # Manifest içeriğini kontrol et
+        try:
+            with open(manifest_path, 'r', encoding='utf-8') as f:
+                manifest_data = json.load(f)
+            
+            # Manifest'i doğrula
+            is_valid, validation_errors = validate_manifest_verbose(manifest_data)
+            
+            if is_valid:
+                print("✅ manifest.json geçerli")
+            else:
+                print("❌ manifest.json geçersiz:")
+                for error in validation_errors:
+                    print(f"   • {error}")
+                    errors.append(f"Manifest hatası: {error}")
+            
+            # Giriş dosyası kontrolü
+            if "entry" in manifest_data:
+                entry_file = folder / manifest_data["entry"]
+                if entry_file.exists():
+                    print(f"✅ Giriş dosyası mevcut: {manifest_data['entry']}")
+                else:
+                    error_msg = f"Giriş dosyası bulunamadı: {manifest_data['entry']}"
+                    print(f"❌ {error_msg}")
+                    errors.append(error_msg)
+            
+            # Dil kontrolü
+            if "language" in manifest_data:
+                language = manifest_data["language"].lower()
+                if language in ["python", "lua"]:
+                    print(f"✅ Desteklenen dil: {language}")
+                else:
+                    warning_msg = f"Desteklenmeyen dil: {language}"
+                    print(f"⚠️  {warning_msg}")
+                    warnings.append(warning_msg)
+            
+        except json.JSONDecodeError as e:
+            error_msg = f"manifest.json JSON formatı geçersiz: {str(e)}"
+            print(f"❌ {error_msg}")
+            errors.append(error_msg)
+        except Exception as e:
+            error_msg = f"manifest.json okunamadı: {str(e)}"
+            print(f"❌ {error_msg}")
+            errors.append(error_msg)
+    
+    # 2. Klasör içeriği kontrolü
+    files = list(folder.iterdir())
+    if not files:
+        warnings.append("Klasör boş")
+        print("⚠️  Klasör boş")
+    else:
+        print(f"✅ Klasör içeriği: {len(files)} öğe")
+    
+    # 3. Önerilen dosya yapısı kontrolü
+    recommended_files = ["manifest.json", "README.md", "requirements.txt"]
+    missing_recommended = []
+    
+    for rec_file in recommended_files:
+        if not (folder / rec_file).exists():
+            missing_recommended.append(rec_file)
+    
+    if missing_recommended:
+        print("💡 Önerilen dosyalar eksik:")
+        for missing in missing_recommended:
+            print(f"   • {missing}")
+    
+    # 4. Dosya boyutu kontrolü
+    try:
+        total_size = 0
+        file_count = 0
+        
+        for file_path in folder.rglob("*"):
+            if file_path.is_file():
+                file_count += 1
+                total_size += file_path.stat().st_size
+        
+        print(f"📊 İstatistikler: {file_count} dosya, {format_size(total_size)}")
+        
+        # Büyük dosyalar için uyarı
+        if total_size > 100 * 1024 * 1024:  # 100MB
+            warnings.append(f"Büyük uygulama boyutu: {format_size(total_size)}")
+    
+    except Exception as e:
+        warnings.append(f"Dosya boyutu hesaplanamadı: {str(e)}")
+    
+    # Sonuçları göster
+    print("\n" + "=" * 50)
+    print("📋 Doğrulama Sonuçları:")
+    
+    if not errors and not warnings:
+        print("🎉 Mükemmel! Uygulama klasörü tamamen geçerli.")
+        print("✅ Kurulum için hazır.")
+    elif not errors:
+        print("✅ Uygulama klasörü geçerli.")
+        if warnings:
+            print("⚠️  Bazı uyarılar var:")
+            for warning in warnings:
+                print(f"   • {warning}")
+    else:
+        print("❌ Uygulama klasörü geçersiz.")
+        print("🔧 Düzeltilmesi gereken hatalar:")
+        for error in errors:
+            print(f"   • {error}")
+        
+        if warnings:
+            print("⚠️  Ek uyarılar:")
+            for warning in warnings:
+                print(f"   • {warning}")
+    
+    # Öneriler
+    if errors or warnings:
+        print("\n💡 Öneriler:")
+        if not manifest_path.exists():
+            print("• manifest.json dosyası oluşturun")
+            print("• Örnek: clapp init komutu ile başlayabilirsiniz")
+        
+        if missing_recommended:
+            print("• Önerilen dosyaları ekleyin:")
+            for missing in missing_recommended:
+                if missing == "README.md":
+                    print(f"  - {missing}: Uygulama açıklaması")
+                elif missing == "requirements.txt":
+                    print(f"  - {missing}: Python bağımlılıkları (Python uygulamaları için)")
+        
+        if warnings:
+            print("• Uyarıları gözden geçirin ve gerekirse düzeltin")
+    
+    print(f"\n🔧 Daha fazla yardım için: clapp doctor")
+    
+    return len(errors) == 0
+
+def format_size(size_bytes):
+    """Dosya boyutunu formatlar"""
+    if size_bytes == 0:
+        return "0 B"
+    
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    
+    return f"{size_bytes:.1f} TB"
+
+def validate_multiple_folders(folder_paths):
+    """Birden fazla klasörü doğrular"""
+    results = []
+    
+    for folder_path in folder_paths:
+        print(f"\n{'='*60}")
+        result = validate_app_folder(folder_path)
+        results.append((folder_path, result))
+    
+    # Özet
+    print(f"\n{'='*60}")
+    print("📊 Toplu Doğrulama Özeti:")
+    
+    valid_count = sum(1 for _, result in results if result)
+    invalid_count = len(results) - valid_count
+    
+    print(f"✅ Geçerli: {valid_count}")
+    print(f"❌ Geçersiz: {invalid_count}")
+    
+    if invalid_count > 0:
+        print("\n❌ Geçersiz klasörler:")
+        for folder_path, result in results:
+            if not result:
+                print(f"   • {folder_path}")
+    
+    return invalid_count == 0
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Kullanım: python validate_command.py <klasör_yolu>")
+        print("Örnek: python validate_command.py apps/my-app")
+        sys.exit(1)
+    
+    folder_paths = sys.argv[1:]
+    
+    if len(folder_paths) == 1:
+        success = validate_app_folder(folder_paths[0])
+        sys.exit(0 if success else 1)
+    else:
+        success = validate_multiple_folders(folder_paths)
+        sys.exit(0 if success else 1) 

version_command.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+version_command.py - Sürüm bilgisi modülü
+
+Bu modül `clapp version` komutunu destekler ve
+clapp'in sürüm bilgilerini gösterir.
+"""
+
+import sys
+import platform
+import json
+from pathlib import Path
+
+def get_version_info():
+    """Sürüm bilgilerini toplar"""
+    # version.json dosyasından sürüm bilgisini oku
+    version_file = Path("version.json")
+    
+    if version_file.exists():
+        try:
+            with open(version_file, 'r', encoding='utf-8') as f:
+                version_data = json.load(f)
+            
+            app_name = version_data.get("name", "clapp")
+            version = version_data.get("version", "1.0.0")
+            author = version_data.get("author", "Bilinmiyor")
+            
+        except Exception:
+            app_name = "clapp"
+            version = "1.0.0"
+            author = "Bilinmiyor"
+    else:
+        app_name = "clapp"
+        version = "1.0.0"
+        author = "Bilinmiyor"
+    
+    # Sistem bilgileri
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    system_info = platform.system()
+    machine = platform.machine()
+    
+    return {
+        "app_name": app_name,
+        "version": version,
+        "author": author,
+        "python_version": python_version,
+        "system": system_info,
+        "machine": machine,
+        "platform": f"{system_info} {platform.release()}"
+    }
+
+def print_version(format_type="default"):
+    """Sürüm bilgisini yazdırır"""
+    info = get_version_info()
+    
+    if format_type == "short":
+        print(info["version"])
+    elif format_type == "json":
+        import json
+        output = {
+            "version": info["version"],
+            "python": info["python_version"],
+            "os": info["system"],
+            "machine": info["machine"]
+        }
+        print(json.dumps(output, indent=2))
+    else:  # default
+        print(f"🚀 {info['app_name']} v{info['version']}")
+        print(f"🐍 Python {info['python_version']}")
+        print(f"💻 Platform: {info['platform']} ({info['machine']})")
+        print(f"👨‍💻 Yazar: {info['author']}")
+
+def print_detailed_version():
+    """Detaylı sürüm bilgisini yazdırır"""
+    info = get_version_info()
+    
+    print("📋 clapp Detaylı Sürüm Bilgileri")
+    print("=" * 50)
+    
+    # Temel bilgiler
+    print("🚀 Uygulama Bilgileri:")
+    print(f"   Ad: {info['app_name']}")
+    print(f"   Sürüm: {info['version']}")
+    print(f"   Yazar: {info['author']}")
+    print()
+    
+    # Python bilgileri
+    print("🐍 Python Bilgileri:")
+    print(f"   Sürüm: {info['python_version']}")
+    print(f"   Çalıştırılabilir: {sys.executable}")
+    print(f"   Prefix: {sys.prefix}")
+    print()
+    
+    # Platform bilgileri
+    print("💻 Platform Bilgileri:")
+    print(f"   İşletim Sistemi: {info['system']}")
+    print(f"   Sürüm: {platform.release()}")
+    print(f"   Mimari: {info['machine']}")
+    print(f"   İşlemci: {platform.processor()}")
+    print()
+    
+    # Modül bilgileri
+    print("📦 Modül Bilgileri:")
+    try:
+        import flet
+        print(f"   Flet: v{flet.__version__}")
+    except ImportError:
+        print("   Flet: Yüklü değil")
+    
+    # Ek bilgiler
+    print()
+    print("📁 Dizin Bilgileri:")
+    print(f"   Çalışma Dizini: {Path.cwd()}")
+    
+    # apps/ dizini kontrolü
+    apps_dir = Path("apps")
+    if apps_dir.exists():
+        app_count = len([d for d in apps_dir.iterdir() if d.is_dir()])
+        print(f"   Apps Dizini: {apps_dir.resolve()} ({app_count} uygulama)")
+    else:
+        print("   Apps Dizini: Bulunamadı")
+
+def check_latest_version():
+    """En son sürümü kontrol eder (placeholder)"""
+    print("🔍 En son sürüm kontrol ediliyor...")
+    print("⚠️  Bu özellik henüz mevcut değil.")
+    print("📞 Manuel kontrol için: https://github.com/user/clapp")
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        arg = sys.argv[1]
+        if arg == "--short":
+            print_version("short")
+        elif arg == "--json":
+            print_version("json")
+        elif arg == "--detailed":
+            print_detailed_version()
+        elif arg == "--latest":
+            check_latest_version()
+        else:
+            print_version("default")
+    else:
+        print_version("default")