clapp-pm 1.0.9__py3-none-any.whl → 1.0.11__py3-none-any.whl

backup_current/installer.py

@@ -0,0 +1,323 @@
+import os
+import zipfile
+import urllib.request
+import tempfile
+import shutil
+import json
+from manifest_validator import validate_manifest_verbose
+from package_registry import app_exists
+
+def find_app_folder(extract_path, app_name):
+    """
+    Zip çıkarıldıktan sonra, extract_path altında **/packages/{app_name} klasörünü bulur.
+    """
+    for root, dirs, files in os.walk(extract_path):
+        if os.path.basename(root) == app_name and os.path.basename(os.path.dirname(root)) == "packages":
+            return root
+    return None
+
+
+def install_package(source, force=False):
+    """
+    Bir .clapp paketini zip dosyasından veya URL'den yükler.
+    """
+    temp_dir = None
+    try:
+        temp_dir = tempfile.mkdtemp()
+        if source.startswith(('http://', 'https://')):
+            zip_path = download_package(source, temp_dir)
+            if not zip_path:
+                return False, "Paket indirilemedi"
+        else:
+            if not os.path.exists(source):
+                return False, f"Dosya bulunamadı: {source}"
+            zip_path = source
+        extract_path = os.path.join(temp_dir, "extracted")
+        success, message = extract_package(zip_path, extract_path)
+        if not success:
+            return False, message
+
+        # --- YENİ: Doğru app klasörünü bul ---
+        # Önce manifesti bulmak için tüm app klasörlerini tara
+        app_folder = None
+        manifest = None
+        manifest_path = None
+        # Tüm packages altındaki app klasörlerini bul
+        for root, dirs, files in os.walk(extract_path):
+            if "manifest.json" in files:
+                with open(os.path.join(root, "manifest.json"), 'r', encoding='utf-8') as f:
+                    try:
+                        m = json.load(f)
+                        if 'name' in m:
+                            app_folder = root
+                            manifest = m
+                            manifest_path = os.path.join(root, "manifest.json")
+                            break
+                    except Exception:
+                        continue
+        if not app_folder or not manifest:
+            return False, "Uygulama klasörü bulunamadı: manifest.json"
+        app_name = manifest['name']
+
+        # --- YENİ: Sadece packages/{app_name} klasörünü bul ve kopyala ---
+        app_real_folder = find_app_folder(extract_path, app_name)
+        if not app_real_folder:
+            return False, f"Uygulama klasörü bulunamadı: packages/{app_name}"
+
+        # Manifesti doğrula
+        is_valid, errors = validate_manifest_file(os.path.join(app_real_folder, "manifest.json"))
+        if not is_valid:
+            error_msg = "Manifest doğrulama hatası:\n" + "\n".join(errors)
+            return False, error_msg
+
+        # Giriş dosyasının varlığını kontrol et
+        entry_file = manifest['entry']
+        entry_path = os.path.join(app_real_folder, entry_file)
+        if not os.path.exists(entry_path):
+            return False, f"Giriş dosyası bulunamadı: {entry_file}"
+
+        # Hedef dizini oluştur
+        target_dir = os.path.join("apps", app_name)
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+        shutil.copytree(app_real_folder, target_dir)
+        return True, f"✅ '{app_name}' başarıyla yüklendi!"
+    except Exception as e:
+        return False, f"Yükleme hatası: {e}"
+    finally:
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+def download_package(url, temp_dir):
+    """
+    Paketi URL'den indirir.
+    
+    Args:
+        url (str): İndirilecek URL
+        temp_dir (str): Geçici dizin
+        
+    Returns:
+        str or None: İndirilen dosyanın yolu veya None
+    """
+    try:
+        print(f"Paket indiriliyor: {url}")
+        
+        # Dosya adını URL'den çıkar
+        filename = os.path.basename(url)
+        if not filename.endswith('.zip'):
+            filename += '.zip'
+        
+        zip_path = os.path.join(temp_dir, filename)
+        
+        # Dosyayı indir
+        urllib.request.urlretrieve(url, zip_path)
+        
+        print(f"✅ İndirme tamamlandı: {filename}")
+        return zip_path
+        
+    except Exception as e:
+        print(f"❌ İndirme hatası: {e}")
+        return None
+
+def extract_package(zip_path, extract_path):
+    """
+    Zip dosyasını çıkarır.
+    
+    Args:
+        zip_path (str): Zip dosyasının yolu
+        extract_path (str): Çıkarılacak dizin
+        
+    Returns:
+        tuple: (success: bool, message: str)
+    """
+    try:
+        # Çıkarma dizinini oluştur
+        os.makedirs(extract_path, exist_ok=True)
+        
+        # Zip dosyasını aç ve çıkar
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_path)
+        
+        print(f"✅ Paket çıkarıldı: {extract_path}")
+        return True, "Paket başarıyla çıkarıldı"
+        
+    except zipfile.BadZipFile:
+        return False, "Geçersiz zip dosyası"
+    except Exception as e:
+        return False, f"Çıkarma hatası: {e}"
+
+def validate_manifest_file(manifest_path):
+    """
+    Manifest dosyasını doğrular.
+    
+    Args:
+        manifest_path (str): Manifest dosyasının yolu
+        
+    Returns:
+        tuple: (is_valid: bool, errors: list)
+    """
+    if not os.path.exists(manifest_path):
+        return False, ["Manifest dosyası bulunamadı"]
+    
+    try:
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+        
+        return validate_manifest_verbose(manifest)
+        
+    except json.JSONDecodeError as e:
+        return False, [f"JSON formatı hatalı: {e}"]
+    except Exception as e:
+        return False, [f"Dosya okuma hatası: {e}"]
+
+def create_package_from_directory(source_dir, output_path=None):
+    """
+    Dizinden .clapp paketi oluşturur.
+    
+    Args:
+        source_dir (str): Kaynak dizin
+        output_path (str): Çıktı dosyası yolu (opsiyonel)
+        
+    Returns:
+        tuple: (success: bool, message: str, output_file: str)
+    """
+    try:
+        # Manifest dosyasını kontrol et
+        manifest_path = os.path.join(source_dir, "manifest.json")
+        is_valid, errors = validate_manifest_file(manifest_path)
+        
+        if not is_valid:
+            error_msg = "Manifest doğrulama hatası:\n" + "\n".join(errors)
+            return False, error_msg, None
+        
+        # Manifest'i yükle
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+        
+        app_name = manifest['name']
+        
+        # Çıktı dosyası yolunu belirle
+        if not output_path:
+            output_path = f"{app_name}.clapp.zip"
+        
+        # Zip dosyasını oluştur
+        with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zip_ref:
+            for root, dirs, files in os.walk(source_dir):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arc_path = os.path.relpath(file_path, source_dir)
+                    zip_ref.write(file_path, arc_path)
+        
+        return True, f"✅ Paket oluşturuldu: {output_path}", output_path
+        
+    except Exception as e:
+        return False, f"Paket oluşturma hatası: {e}", None
+
+def install_from_directory(source_dir, force=False):
+    """
+    Dizinden doğrudan uygulama yükler.
+    
+    Args:
+        source_dir (str): Kaynak dizin
+        force (bool): Mevcut uygulamanın üzerine yazılmasına izin ver
+        
+    Returns:
+        tuple: (success: bool, message: str)
+    """
+    try:
+        # Manifest dosyasını kontrol et
+        manifest_path = os.path.join(source_dir, "manifest.json")
+        is_valid, errors = validate_manifest_file(manifest_path)
+        
+        if not is_valid:
+            error_msg = "Manifest doğrulama hatası:\n" + "\n".join(errors)
+            return False, error_msg
+        
+        # Manifest'i yükle
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+        
+        app_name = manifest['name']
+        
+        # Uygulama zaten var mı kontrol et
+        if app_exists(app_name) and not force:
+            return False, f"Uygulama '{app_name}' zaten yüklü. --force kullanarak üzerine yazabilirsiniz."
+        
+        # Giriş dosyasının varlığını kontrol et
+        entry_file = manifest['entry']
+        entry_path = os.path.join(source_dir, entry_file)
+        if not os.path.exists(entry_path):
+            return False, f"Giriş dosyası bulunamadı: {entry_file}"
+        
+        # Hedef dizini oluştur
+        target_dir = os.path.join("apps", app_name)
+        
+        # Mevcut dizini sil (eğer varsa)
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+        
+        # Dosyaları kopyala
+        shutil.copytree(source_dir, target_dir)
+        
+        return True, f"✅ '{app_name}' başarıyla yüklendi!"
+        
+    except Exception as e:
+        return False, f"Yükleme hatası: {e}"
+
+def uninstall_package(app_name):
+    """
+    Uygulamayı kaldırır.
+    
+    Args:
+        app_name (str): Kaldırılacak uygulama adı
+        
+    Returns:
+        tuple: (success: bool, message: str)
+    """
+    try:
+        if not app_exists(app_name):
+            return False, f"Uygulama '{app_name}' bulunamadı"
+        
+        # Uygulama dizinini sil
+        app_dir = os.path.join("apps", app_name)
+        shutil.rmtree(app_dir)
+        
+        return True, f"✅ '{app_name}' başarıyla kaldırıldı!"
+        
+    except Exception as e:
+        return False, f"Kaldırma hatası: {e}"
+
+def list_installable_files(directory="."):
+    """
+    Dizindeki yüklenebilir .clapp dosyalarını listeler.
+    
+    Args:
+        directory (str): Aranacak dizin
+        
+    Returns:
+        list: .clapp dosyalarının listesi
+    """
+    clapp_files = []
+    
+    for file in os.listdir(directory):
+        if file.endswith('.clapp.zip') or file.endswith('.zip'):
+            file_path = os.path.join(directory, file)
+            clapp_files.append(file_path)
+    
+    return clapp_files
+
+if __name__ == "__main__":
+    # Test için örnek kullanım
+    print("clapp Installer Test")
+    print("=" * 30)
+    
+    # Mevcut dizindeki .clapp dosyalarını listele
+    installable = list_installable_files()
+    if installable:
+        print("Yüklenebilir dosyalar:")
+        for file in installable:
+            print(f"  - {file}")
+    else:
+        print("Yüklenebilir dosya bulunamadı")
+    
+    print("\nTest tamamlandı.") 

backup_current/list_command.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+list_command.py - clapp List Command
+
+Bu modül 'clapp list' komutunu uygular.
+Kurulu uygulamaları farklı formatlarda listeler.
+"""
+
+import os
+import json
+import sys
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+def get_apps_directory() -> str:
+    """Uygulamaların kurulu olduğu dizini döndürür"""
+    # Kullanıcının home dizininde .clapp klasörü
+    home_dir = Path.home()
+    clapp_dir = home_dir / ".clapp"
+    apps_dir = clapp_dir / "apps"
+    
+    return str(apps_dir)
+
+def load_app_manifest(app_path: str) -> Optional[Dict[str, Any]]:
+    """Uygulama manifest'ini yükler"""
+    manifest_path = os.path.join(app_path, "manifest.json")
+    
+    if not os.path.exists(manifest_path):
+        return None
+    
+    try:
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+def get_installed_apps_with_info() -> List[Dict[str, Any]]:
+    """Kurulu uygulamaların detaylı bilgilerini döndürür"""
+    apps_dir = get_apps_directory()
+    apps = []
+    
+    if not os.path.exists(apps_dir):
+        return apps
+    
+    for item in os.listdir(apps_dir):
+        item_path = os.path.join(apps_dir, item)
+        
+        if not os.path.isdir(item_path) or item.startswith('.'):
+            continue
+        
+        manifest = load_app_manifest(item_path)
+        
+        if manifest:
+            app_info = {
+                'name': manifest.get('name', item),
+                'version': manifest.get('version', '?'),
+                'language': manifest.get('language', '?'),
+                'description': manifest.get('description', 'Açıklama yok'),
+                'entry': manifest.get('entry', '?'),
+                'dependencies': manifest.get('dependencies', []),
+                'folder': item,
+                'path': item_path
+            }
+        else:
+            app_info = {
+                'name': item,
+                'version': '?',
+                'language': '?',
+                'description': 'Manifest bulunamadı',
+                'entry': '?',
+                'dependencies': [],
+                'folder': item,
+                'path': item_path
+            }
+        
+        apps.append(app_info)
+    
+    return apps
+
+def format_table_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları tablo formatında formatlar"""
+    if not apps:
+        return "📭 Hiç uygulama kurulu değil."
+    
+    # Başlık
+    output = []
+    output.append(f"📦 Kurulu Uygulamalar ({len(apps)})")
+    output.append("=" * 80)
+    
+    # Sütun başlıkları
+    output.append(f"{'Ad':<20} {'Sürüm':<10} {'Dil':<10} {'Açıklama':<30}")
+    output.append("-" * 80)
+    
+    # Uygulamalar
+    for app in sorted(apps, key=lambda x: x['name'].lower()):
+        name = app['name'][:19]
+        version = app['version'][:9]
+        language = app['language'][:9]
+        description = app['description'][:29]
+        
+        output.append(f"{name:<20} {version:<10} {language:<10} {description:<30}")
+    
+    return "\n".join(output)
+
+def format_simple_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları basit liste formatında formatlar"""
+    if not apps:
+        return "📭 Hiç uygulama kurulu değil."
+    
+    output = []
+    output.append(f"📦 Kurulu Uygulamalar ({len(apps)}):")
+    
+    for app in sorted(apps, key=lambda x: x['name'].lower()):
+        name = app['name']
+        version = app['version']
+        language = app['language']
+        output.append(f"  • {name} (v{version}) - {language}")
+    
+    return "\n".join(output)
+
+def format_json_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları JSON formatında formatlar"""
+    return json.dumps(apps, indent=2, ensure_ascii=False)
+
+def format_detailed_output(apps: List[Dict[str, Any]]) -> str:
+    """Uygulamaları detaylı formatda formatlar"""
+    if not apps:
+        return "📭 Hiç uygulama kurulu değil."
+    
+    output = []
+    output.append(f"📦 Kurulu Uygulamalar ({len(apps)})")
+    output.append("=" * 60)
+    
+    for i, app in enumerate(sorted(apps, key=lambda x: x['name'].lower()), 1):
+        output.append(f"\n{i}. {app['name']}")
+        output.append(f"   Sürüm: {app['version']}")
+        output.append(f"   Dil: {app['language']}")
+        output.append(f"   Açıklama: {app['description']}")
+        output.append(f"   Entry: {app['entry']}")
+        output.append(f"   Klasör: {app['folder']}")
+        output.append(f"   Yol: {app['path']}")
+        
+        if app['dependencies']:
+            output.append(f"   Bağımlılıklar: {', '.join(app['dependencies'])}")
+        else:
+            output.append(f"   Bağımlılıklar: Yok")
+    
+    return "\n".join(output)
+
+def filter_apps_by_language(apps: List[Dict[str, Any]], language: str) -> List[Dict[str, Any]]:
+    """Uygulamaları dile göre filtreler"""
+    return [app for app in apps if app['language'].lower() == language.lower()]
+
+def filter_apps_by_name(apps: List[Dict[str, Any]], search_term: str) -> List[Dict[str, Any]]:
+    """Uygulamaları isme göre filtreler"""
+    search_term = search_term.lower()
+    return [app for app in apps if search_term in app['name'].lower() or search_term in app['description'].lower()]
+
+def list_apps(format_type: str = "table", language_filter: str = None, search_term: str = None) -> str:
+    """
+    Ana list fonksiyonu
+    
+    Args:
+        format_type: Çıktı formatı (table, simple, json, detailed)
+        language_filter: Dil filtresi (python, lua, vb.)
+        search_term: Arama terimi
+        
+    Returns:
+        Formatlanmış çıktı
+    """
+    apps = get_installed_apps_with_info()
+    
+    # Filtreleri uygula
+    if language_filter:
+        apps = filter_apps_by_language(apps, language_filter)
+    
+    if search_term:
+        apps = filter_apps_by_name(apps, search_term)
+    
+    # Formatı uygula
+    if format_type == "json":
+        return format_json_output(apps)
+    elif format_type == "simple":
+        return format_simple_output(apps)
+    elif format_type == "detailed":
+        return format_detailed_output(apps)
+    else:  # table (default)
+        return format_table_output(apps)
+
+def show_help():
+    """Yardım mesajını gösterir"""
+    help_text = """
+clapp list - Kurulu uygulamaları listeler
+
+Kullanım:
+    python list_command.py [seçenekler]
+
+Seçenekler:
+    --format FORMAT     Çıktı formatı (table, simple, json, detailed)
+    --language LANG     Dil filtresi (python, lua, vb.)
+    --search TERM       Arama terimi (ad veya açıklamada)
+    --help             Bu yardım mesajını göster
+
+Örnekler:
+    python list_command.py
+    python list_command.py --format json
+    python list_command.py --format simple
+    python list_command.py --format detailed
+    python list_command.py --language python
+    python list_command.py --search calculator
+    python list_command.py --language python --format detailed
+    """
+    print(help_text.strip())
+
+def main():
+    """CLI entry point"""
+    # Komut satırı argümanlarını parse et
+    args = sys.argv[1:]
+    
+    if "--help" in args or "-h" in args:
+        show_help()
+        sys.exit(0)
+    
+    format_type = "table"
+    language_filter = None
+    search_term = None
+    
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        
+        if arg == "--format" and i + 1 < len(args):
+            format_type = args[i + 1]
+            i += 2
+        elif arg == "--language" and i + 1 < len(args):
+            language_filter = args[i + 1]
+            i += 2
+        elif arg == "--search" and i + 1 < len(args):
+            search_term = args[i + 1]
+            i += 2
+        else:
+            print(f"❌ Bilinmeyen argüman: {arg}")
+            print("Yardım için: python list_command.py --help")
+            sys.exit(1)
+    
+    # Format kontrolü
+    valid_formats = ["table", "simple", "json", "detailed"]
+    if format_type not in valid_formats:
+        print(f"❌ Geçersiz format: {format_type}")
+        print(f"Geçerli formatlar: {', '.join(valid_formats)}")
+        sys.exit(1)
+    
+    # Uygulamaları listele
+    try:
+        output = list_apps(format_type, language_filter, search_term)
+        print(output)
+    except Exception as e:
+        print(f"❌ Hata: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()