pymulakat 1.0.0__tar.gz

pymulakat-1.0.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pymulakat
+Version: 1.0.0
+Summary: Profesyonel Python Mülakat Platformu CLI
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Requires-Dist: requests>=2.28
+Requires-Dist: PyJWT>=2.0

pymulakat-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pymulakat"
+version = "1.0.0"
+description = "Profesyonel Python Mülakat Platformu CLI"
+requires-python = ">=3.8"
+dependencies = [
+    "click>=8.0",
+    "rich>=13.0",
+    "requests>=2.28",
+    "PyJWT>=2.0",
+]
+
+[project.scripts]
+pymulakat = "pymulakat.main:cli"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

pymulakat-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pymulakat-1.0.0/src/pymulakat/main.py

@@ -0,0 +1,901 @@
+#!/usr/bin/env python3
+"""
+PyMulakat CLI - Modern ve Profesyonel Mülakat Platformu Arayüzü
+"""
+import http.server
+import socketserver
+import urllib.parse
+import secrets
+from threading import Thread
+import time
+import os
+import sys
+import stat
+import errno
+import json
+import base64
+import logging
+import subprocess
+import tempfile
+import re
+import requests
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Prompt, Confirm
+from rich.theme import Theme
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+from rich.live import Live
+from rich.layout import Layout
+from rich.box import ROUNDED
+
+# ─────────────────────────────────────────────
+# 🎨 Tema & Console
+# ─────────────────────────────────────────────
+custom_theme = Theme({
+    "info":      "cyan",
+    "warning":   "yellow",
+    "error":     "bold red",
+    "success":   "bold green",
+    "primary":   "bold blue",
+    "secondary": "dim white",
+    "accent":    "magenta",
+})
+console = Console(theme=custom_theme)
+
+# ─────────────────────────────────────────────
+# 🔧 Sabitler
+# ─────────────────────────────────────────────
+API_BASE          = os.getenv("API_URL", "https://datascience-tutor-backend-production.up.railway.app")
+PYMULAKAT_DIR     = Path.home() / ".pymulakat"
+TOKEN_FILE        = PYMULAKAT_DIR / "token"
+CONFIG_FILE       = PYMULAKAT_DIR / "config.json"
+META_FILE         = Path(".interview_meta.json")
+MIN_PYTHON_VERSION = (3, 8)
+
+logger = logging.getLogger("pymulakat")
+
+# ═══════════════════════════════════════════════════════════
+# ⚙️  KULLANICI İZİN KONFİGÜRASYONU
+# ═══════════════════════════════════════════════════════════
+
+# Varsayılan izinler (octal)
+DEFAULT_PERMISSIONS = {
+    "token_file":    0o600,   # Sadece owner r/w
+    "config_file":   0o600,   # Sadece owner r/w
+    "solution_file": 0o644,   # Owner r/w, diğerleri r
+    "test_file":     0o600,   # Gizli: sadece owner r/w
+    "meta_file":     0o644,   # Owner r/w, diğerleri r
+    "pymulakat_dir": 0o700,   # Sadece owner erişebilir
+}
+
+# İzin seti şablonları (kullanıcı seçer)
+PERMISSION_PRESETS = {
+    "private":  {"solution_file": 0o600, "meta_file": 0o600, "pymulakat_dir": 0o700},
+    "standard": {"solution_file": 0o644, "meta_file": 0o644, "pymulakat_dir": 0o700},
+    "shared":   {"solution_file": 0o664, "meta_file": 0o664, "pymulakat_dir": 0o755},
+}
+
+
+def load_permission_config() -> dict:
+    """
+    İzin konfigürasyonunu ~/.pymulakat/config.json'dan yükler.
+    Dosya yoksa varsayılanları döner.
+    """
+    if CONFIG_FILE.exists():
+        try:
+            raw = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            perms = DEFAULT_PERMISSIONS.copy()
+            for key, val in raw.get("permissions", {}).items():
+                if key in perms:
+                    # JSON'da int veya "0o644" string olabilir
+                    perms[key] = int(str(val), 8) if isinstance(val, str) else val
+            return perms
+        except Exception as e:
+            logger.warning(f"Config okunamadı, varsayılanlar kullanılıyor: {e}")
+    return DEFAULT_PERMISSIONS.copy()
+
+
+def save_permission_config(perms: dict):
+    """İzin ayarlarını config.json'a kaydeder."""
+    _ensure_pymulakat_dir()
+    existing = {}
+    if CONFIG_FILE.exists():
+        try:
+            existing = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    existing["permissions"] = {k: oct(v) for k, v in perms.items()}
+    _atomic_write(CONFIG_FILE, json.dumps(existing, indent=2, ensure_ascii=False))
+    _set_mode(CONFIG_FILE, perms.get("config_file", 0o600))
+
+
+# ═══════════════════════════════════════════════════════════
+# 🗂️  DÜŞÜK SEVİYE DOSYA YARDIMCILARI
+# ═══════════════════════════════════════════════════════════
+
+def _ensure_pymulakat_dir():
+    """~/.pymulakat dizinini güvenli şekilde oluşturur."""
+    try:
+        PYMULAKAT_DIR.mkdir(parents=True, exist_ok=True)
+        _set_mode(PYMULAKAT_DIR, load_permission_config().get("pymulakat_dir", 0o700))
+    except PermissionError as e:
+        raise PermissionError(
+            f"❌ '{PYMULAKAT_DIR}' dizini oluşturulamadı: {e}\n"
+            f"   Çözüm: chmod 700 {PYMULAKAT_DIR.parent}"
+        ) from e
+
+
+def _set_mode(path: Path, mode: int):
+    """Dosya/dizin iznini ayarlar; hata varsa loglar ama patlamaz."""
+    try:
+        path.chmod(mode)
+    except PermissionError:
+        logger.warning(f"⚠️  İzin ayarlanamadı: {path} → {oct(mode)}")
+
+
+def _atomic_write(path: Path, content: str, encoding: str = "utf-8"):
+    """
+    İçeriği geçici dosyaya yazar, sonra atomik olarak rename eder.
+    Yarım yazma / bozuk dosya riskini ortadan kaldırır.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    try:
+        tmp_path.write_text(content, encoding=encoding)
+        tmp_path.replace(path)   # atomic on POSIX; near-atomic on Windows
+    except OSError as e:
+        tmp_path.unlink(missing_ok=True)
+        _raise_os_error(e, path)
+
+
+def _raise_os_error(e: OSError, path: Path):
+    """OSError'u anlaşılır mesaja çevirir."""
+    if e.errno == errno.EACCES:
+        raise PermissionError(f"❌ Erişim reddedildi: '{path}'. Çözüm: chmod 644 {path}") from e
+    if e.errno == errno.ENOSPC:
+        raise OSError(f"❌ Disk dolu, '{path}' yazılamadı.") from e
+    if e.errno == errno.EROFS:
+        raise OSError(f"❌ Salt-okunur dosya sistemi: '{path}'.") from e
+    raise
+
+
+def get_permissions_info(path: Path) -> dict:
+    """Dosya/dizin izin bilgilerini döner."""
+    if not path.exists():
+        return {"path": str(path), "exists": False}
+    st = path.stat()
+    return {
+        "path":      str(path),
+        "exists":    True,
+        "mode":      stat.filemode(st.st_mode),
+        "octal":     oct(stat.S_IMODE(st.st_mode)),
+        "readable":  os.access(path, os.R_OK),
+        "writable":  os.access(path, os.W_OK),
+        "owner_uid": st.st_uid,
+    }
+
+
+# ═══════════════════════════════════════════════════════════
+# 🔐 TOKEN YÖNETİMİ
+# ═══════════════════════════════════════════════════════════
+
+def get_token() -> Optional[str]:
+    if TOKEN_FILE.exists():
+        try:
+            return TOKEN_FILE.read_text(encoding="utf-8").strip()
+        except PermissionError:
+            console.print("[error]❌ Token dosyası okunamadı — izin hatası.[/]")
+    return None
+
+
+def save_token(token: str):
+    perms = load_permission_config()
+    _ensure_pymulakat_dir()
+    _atomic_write(TOKEN_FILE, token)
+    _set_mode(TOKEN_FILE, perms["token_file"])
+
+
+def get_auth_headers() -> dict:
+    token = get_token()
+    return {"Authorization": f"Bearer {token}"} if token else {}
+
+
+# ═══════════════════════════════════════════════════════════
+# 📄 META DOSYASI
+# ═══════════════════════════════════════════════════════════
+
+def save_interview_meta(question_id: str, lib: str, topic: str, solution_file: str):
+    perms = load_permission_config()
+    meta: dict = {}
+    if META_FILE.exists():
+        try:
+            meta = json.loads(META_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            meta = {}
+    meta[question_id] = {"lib": lib, "topic": topic, "file": solution_file}
+    _atomic_write(META_FILE, json.dumps(meta, ensure_ascii=False, indent=2))
+    _set_mode(META_FILE, perms["meta_file"])
+
+
+def load_interview_meta(question_id: str) -> Optional[dict]:
+    if not META_FILE.exists():
+        return None
+    try:
+        meta = json.loads(META_FILE.read_text(encoding="utf-8"))
+        return meta.get(question_id)
+    except Exception:
+        return None
+
+
+# ═══════════════════════════════════════════════════════════
+# 🔧 Genel Yardımcılar
+# ═══════════════════════════════════════════════════════════
+
+def get_next_solution_filename() -> str:
+    pattern = re.compile(r"solution(\d+)\.py")
+    existing_nums = [
+        int(m.group(1))
+        for f in Path.cwd().glob("solution*.py")
+        if (m := pattern.match(f.name))
+    ]
+    return f"solution{max(existing_nums) + 1 if existing_nums else 1}.py"
+
+
+def get_latest_solution_file() -> Optional[str]:
+    solutions = sorted(Path.cwd().glob("solution*.py"), key=lambda p: p.stat().st_mtime, reverse=True)
+    return solutions[0].name if solutions else None
+
+
+def check_python_version():
+    current = sys.version_info[:2]
+    if current < MIN_PYTHON_VERSION:
+        console.print(Panel(
+            f"[error]❌ Python {MIN_PYTHON_VERSION[0]}.{MIN_PYTHON_VERSION[1]}+ gerekiyor!\n"
+            f"   Mevcut: {sys.version.split()[0]}[/]",
+            title="Versiyon Hatası", border_style="red"
+        ))
+        sys.exit(1)
+
+
+def check_interpreter(lib: str = "python") -> bool:
+    try:
+        result = subprocess.run([lib, "--version"], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            console.print(f"[success]✓[/] {lib} {result.stdout.strip().split()[-1]} bulundu")
+            return True
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+    console.print(f"[error]✗[/] {lib} bulunamadı!")
+    return False
+
+
+def decode_base64_content(encoded: str) -> str:
+    return base64.b64decode(encoded).decode("utf-8")
+
+
+def api_request(method: str, endpoint: str, **kwargs) -> dict:
+    url = f"{API_BASE}{endpoint}"
+    headers = kwargs.pop("headers", {})
+    headers.update(get_auth_headers())
+    try:
+        response = requests.request(method, url, headers=headers, timeout=30, **kwargs)
+        response.raise_for_status()
+        return response.json() if response.content else {}
+    except requests.exceptions.HTTPError as e:
+        detail = e.response.json().get("detail", str(e)) if e.response and e.response.content else str(e)
+        console.print(Panel(f"[error]{detail}[/]", title="API Hatası", border_style="red"))
+        sys.exit(1)
+    except requests.exceptions.ConnectionError:
+        console.print(Panel("[error]Sunucuya bağlanılamadı.[/]", title="Bağlantı Hatası", border_style="red"))
+        sys.exit(1)
+    except requests.exceptions.Timeout:
+        console.print(Panel("[error]İstek zaman aşımına uğradı.[/]", title="Timeout", border_style="red"))
+        sys.exit(1)
+
+
+# ═══════════════════════════════════════════════════════════
+# 🎨 UI Yardımcıları
+# ═══════════════════════════════════════════════════════════
+
+def show_header(title: str, subtitle: str = ""):
+    console.print()
+    content = f"[bold blue]{title}[/]"
+    if subtitle:
+        content += f"\n[dim white]{subtitle}[/]"
+    console.print(Panel(content, box=ROUNDED, border_style="blue", padding=(1, 2)))
+    console.print()
+
+
+def show_success(message: str, title: str = "Başarılı"):
+    console.print(Panel(f"[success]{message}[/]", title=title, border_style="green"))
+
+
+def show_error(message: str, title: str = "Hata"):
+    console.print(Panel(f"[error]{message}[/]", title=title, border_style="red"))
+
+
+# ═══════════════════════════════════════════════════════════
+# 🔒 LOGIN KORUMA DECORATOR'I
+# ═══════════════════════════════════════════════════════════
+
+def require_login(func):
+    """
+    Komutu çalıştırmadan önce geçerli bir token olup olmadığını kontrol eder.
+    Token yoksa kullanıcıya giriş yapmasını söyler ve komutu iptal eder.
+    """
+    import functools
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        token = get_token()
+        if not token:
+            console.print()
+            console.print(Panel(
+                "[error]Bu işlemi gerçekleştirmek için giriş yapmanız gerekiyor.[/]\n\n"
+                "[info]👉 Giriş yapmak için:[/]  [cyan]pymulakat login[/]",
+                title="🔒 Oturum Gerekli",
+                border_style="red",
+            ))
+            console.print()
+            sys.exit(1)
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def create_progress_table(data: list, lib_filter: Optional[str] = None):
+    table = Table(box=ROUNDED, header_style="bold blue", show_lines=True)
+    table.add_column("ID",        style="cyan",    width=8)
+    table.add_column("Kütüphane", style="magenta", width=12)
+    table.add_column("Konu",      style="white",   width=30)
+    table.add_column("Zorluk",    style="yellow",  width=12)
+    for item in data:
+        difficulty_badge = {
+            "Beginner":    "[green]🟢 Beginner[/]",
+            "Junior-Mid":  "[yellow]🟡 Junior-Mid[/]",
+            "Mid-Senior":  "[red]🔴 Mid-Senior[/]",
+        }.get(item.get("difficulty", ""), "⚪ Belirtilmemiş")
+        table.add_row(
+            f"[cyan]#{item['id']}[/]",
+            f"[magenta]{item.get('lib', 'unknown')}[/]",
+            item.get("topic", item.get("title", "Başlıksız")),
+            difficulty_badge,
+        )
+    return table
+
+
+# ═══════════════════════════════════════════════════════════
+# 🔐 AUTH KOMUTLARI
+# ═══════════════════════════════════════════════════════════
+
+@click.group()
+@click.version_option(version="1.0.0", prog_name="pymulakat")
+@click.pass_context
+def cli(ctx):
+    """🎓 PyMulakat CLI - Profesyonel Python Mülakat Platformu"""
+    check_python_version()
+    ctx.ensure_object(dict)
+
+
+@cli.command()
+@click.option("-e", "--email",    prompt="E-posta", help="Kullanıcı e-posta adresi")
+@click.option("-p", "--password", prompt="Şifre", hide_input=True, help="Kullanıcı şifresi")
+def login(email: str, password: str):
+    """🔐 CLI üzerinden giriş yap (OAuth flow)"""
+    show_header("🔐 Giriş", "Hesabınıza bağlanılıyor...")
+
+    with Progress(SpinnerColumn(), TextColumn("[primary]Doğrulanıyor...[/]"), console=console) as progress:
+        progress.add_task("", total=None)
+        try:
+            data       = api_request("POST", "/auth/cli/init", json={"email": email, "password": password})
+            session_id = data.get("session_id")
+            if not session_id:
+                show_error("session_id alınamadı")
+                return
+
+            state        = secrets.token_urlsafe(16)
+            port         = 3000 + secrets.randbelow(1000)
+            redirect_uri = f"http://localhost:{port}/callback"
+            auth_url = (
+                f"http://www.pythonmulakat.com/authorize"
+                f"?session={urllib.parse.quote(session_id)}"
+                f"&redirect_uri={urllib.parse.quote(redirect_uri)}"
+                f"&state={state}"
+            )
+
+            console.print(Panel(
+                f"[info]Lütfen aşağıdaki linki tarayıcınızda açın:[/]\n\n"
+                f"[link={auth_url}]{auth_url}[/]\n\n"
+                f"[secondary]Giriş yapıp onay verdikten sonra token otomatik alınacaktır.[/]",
+                title="🌐 Tarayıcı Onayı", border_style="cyan"
+            ))
+
+            token_received = None
+
+            class CallbackHandler(http.server.BaseHTTPRequestHandler):
+                def do_GET(self):
+                    nonlocal token_received
+                    parsed = urllib.parse.urlparse(self.path)
+                    if parsed.path == "/callback":
+                        params         = urllib.parse.parse_qs(parsed.query)
+                        returned_token = params.get("token", [None])[0]
+                        returned_state = params.get("state", [None])[0]
+                        if returned_token and returned_state == state:
+                            token_received = returned_token
+                            self.send_response(200)
+                            self.send_header("Content-type", "text/html")
+                            self.end_headers()
+                            self.wfile.write(b"Login successful!")
+                        else:
+                            self.send_response(400)
+                            self.end_headers()
+                            self.wfile.write("Onay alınamadı.".encode("utf-8"))
+                    else:
+                        self.send_response(404)
+                        self.end_headers()
+
+                def log_message(self, format, *args):
+                    pass
+
+            def run_server():
+                with socketserver.TCPServer(("localhost", port), CallbackHandler) as httpd:
+                    httpd.handle_request()
+
+            Thread(target=run_server, daemon=True).start()
+
+            try:
+                import webbrowser
+                webbrowser.open(auth_url)
+            except Exception:
+                pass
+
+        except Exception as e:
+            show_error(str(e))
+            return
+
+    with Progress(SpinnerColumn(), TextColumn("[primary]Onay bekleniyor...[/]"), console=console) as progress:
+        progress.add_task("", total=None)
+        for _ in range(60):
+            if token_received:
+                break
+            time.sleep(1)
+
+    if token_received:
+        try:
+            save_token(token_received)
+            show_success("Giriş başarılı! Token kaydedildi.", "✓ Oturum Açıldı")
+        except (PermissionError, OSError) as e:
+            show_error(str(e), "Token Kaydedilemedi")
+    else:
+        show_error("Onay süresi doldu. Lütfen tekrar deneyin.")
+
+
+@cli.command()
+def logout():
+    """🚪 Çıkış yap ve token'ı sil"""
+    if TOKEN_FILE.exists():
+        try:
+            TOKEN_FILE.unlink()
+            show_success("Çıkış yapıldı. Token silindi.", "✓ Oturum Kapatıldı")
+        except PermissionError as e:
+            show_error(f"Token silinemedi: {e}")
+    else:
+        console.print("[warning]⚠ Zaten giriş yapılmamış.[/]")
+
+
+# ═══════════════════════════════════════════════════════════
+# ⚙️  CONFIG KOMUTU — kullanıcıdan izin al
+# ═══════════════════════════════════════════════════════════
+
+@cli.command("config")
+@click.option("--preset", type=click.Choice(["private", "standard", "shared"]),
+              default=None, help="Hazır izin şablonu seç")
+@click.option("--show", is_flag=True, help="Mevcut ayarları göster")
+def config_cmd(preset: Optional[str], show: bool):
+    """⚙️  Dosya izinlerini yapılandır (kullanıcı tarafından)"""
+    show_header("⚙️  İzin Yapılandırması", "Dosya erişim izinlerini özelleştirin")
+
+    perms = load_permission_config()
+
+    if show:
+        table = Table(box=ROUNDED, title="Mevcut İzin Ayarları", header_style="bold blue")
+        table.add_column("Dosya Türü",  style="cyan")
+        table.add_column("Octal İzin",  style="yellow")
+        table.add_column("Açıklama",    style="dim")
+        descriptions = {
+            "token_file":    "JWT token (~/.pymulakat/token)",
+            "config_file":   "Bu config dosyası",
+            "solution_file": "İndirilen çözüm dosyaları",
+            "test_file":     "Gizli test dosyaları",
+            "meta_file":     "Oturum meta verisi",
+            "pymulakat_dir": "~/.pymulakat dizini",
+        }
+        for key, val in perms.items():
+            table.add_row(key, oct(val), descriptions.get(key, ""))
+        console.print(table)
+        return
+
+    if preset:
+        perms.update(PERMISSION_PRESETS[preset])
+        console.print(f"[success]✓[/] '{preset}' şablonu uygulandı.")
+    else:
+        # İnteraktif mod: her izni kullanıcıdan al
+        console.print("[info]Her dosya türü için izin girin (örn: 0o644) veya boş bırakıp varsayılanı kullanın.[/]\n")
+        for key, current in perms.items():
+            raw = Prompt.ask(
+                f"  [cyan]{key}[/]",
+                default=oct(current),
+                show_default=True,
+            ).strip()
+            try:
+                perms[key] = int(raw, 8)
+            except ValueError:
+                console.print(f"  [warning]Geçersiz değer, {oct(current)} korundu.[/]")
+
+    save_permission_config(perms)
+    show_success(f"İzin ayarları kaydedildi → {CONFIG_FILE}", "✓ Kaydedildi")
+
+    # Var olan dosyalara hemen uygula
+    for path, key in [
+        (TOKEN_FILE, "token_file"),
+        (CONFIG_FILE, "config_file"),
+        (META_FILE,   "meta_file"),
+        (PYMULAKAT_DIR, "pymulakat_dir"),
+    ]:
+        if Path(path).exists():
+            _set_mode(Path(path), perms[key])
+
+
+# ═══════════════════════════════════════════════════════════
+# 📋 SORU YÖNETİMİ KOMUTLARI
+# ═══════════════════════════════════════════════════════════
+
+@cli.command("test")
+@click.argument("question_id")
+@click.option("-l", "--lib",  default=None, help="Kütüphane adı (verilmezse meta'dan okunur)")
+@click.option("-f", "--file", default=None, help="Test edilecek dosya (verilmezse en son solution*.py)")
+@require_login
+def test_solution(question_id: str, lib: Optional[str], file: Optional[str]):
+    """🧪 Çözümü yerel olarak test et"""
+    show_header("🧪 Yerel Test", f"Soru #{question_id}")
+
+    if not lib:
+        meta = load_interview_meta(question_id)
+        if meta:
+            lib = meta["lib"]
+            console.print(f"[dim]📌 Meta'dan kütüphane okundu: [cyan]{lib}[/][/]")
+        else:
+            show_error(
+                f"Soru #{question_id} için kütüphane bilgisi bulunamadı.\n"
+                "  → `pymulakat download` ile soruyu indirin veya -l/--lib ile belirtin."
+            )
+            return
+
+    if not file:
+        file = get_latest_solution_file()
+        if not file:
+            show_error("Dizinde solution*.py bulunamadı.")
+            console.print("[info]💡 `pymulakat download` ile önce kodları indirin.[/]")
+            return
+        console.print(f"[info]📄 Otomatik seçilen dosya: [cyan]{file}[/]")
+
+    solution_path = Path(file)
+    if not solution_path.exists():
+        show_error(f"Dosya bulunamadı: {file}")
+        return
+
+    try:
+        solution_code = solution_path.read_text(encoding="utf-8")
+    except PermissionError as e:
+        show_error(f"Dosya okunamadı (izin hatası): {e}")
+        return
+    except OSError as e:
+        show_error(f"Dosya okunamadı: {e}")
+        return
+
+    console.print("[info]📥 Gizli test scripti sunucudan alınıyor...[/]")
+    try:
+        data = api_request("GET", f"/interviews/download/{lib}/{question_id}")
+        test_code_b64 = data.get("test_encoded")
+        if not test_code_b64:
+            show_error("Bu soru için test kodu bulunamadı.")
+            return
+        test_code = decode_base64_content(test_code_b64)
+    except SystemExit:
+        return
+    except Exception as e:
+        show_error(f"Test kodları alınamadı: {e}")
+        return
+
+    import base64 as _b64
+    sol_b64  = _b64.b64encode(solution_code.encode("utf-8")).decode("ascii")
+    test_b64 = _b64.b64encode(test_code.encode("utf-8")).decode("ascii")
+
+    runner_content = f"""# -*- coding: utf-8 -*-
+import sys, json, base64
+_sol_code  = base64.b64decode("{sol_b64}").decode("utf-8")
+_test_code = base64.b64decode("{test_b64}").decode("utf-8")
+_ns = {{}}
+try:
+    exec(compile(_sol_code, "<solution>", "exec"), _ns)
+except SyntaxError as e:
+    print(f"SYNTAX_ERROR: {{e}}"); sys.exit(1)
+except Exception as e:
+    print(f"RUNTIME_ERROR: {{e}}"); sys.exit(1)
+try:
+    exec(compile(_test_code, "<tests>", "exec"), _ns)
+except Exception as e:
+    print(f"TEST_LOAD_ERROR: {{e}}"); sys.exit(1)
+passed, failed, errors = 0, 0, []
+for name, func in list(_ns.items()):
+    if name.startswith("test_") and callable(func):
+        try:
+            func(); passed += 1
+        except AssertionError as e:
+            failed += 1; errors.append(f"{{name}}: {{str(e)[:120]}}")
+        except Exception as e:
+            failed += 1; errors.append(f"{{name}}: {{type(e).__name__}}: {{str(e)[:120]}}")
+print(f"RESULT_JSON: {{json.dumps({{'passed': passed, 'failed': failed, 'errors': errors}})}}")
+"""
+
+    runner_file: Optional[str] = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as f:
+            f.write(runner_content)
+            runner_file = f.name
+
+        # Runner dosyasını sadece owner çalıştırabilir
+        _set_mode(Path(runner_file), 0o600)
+
+        console.print("[info]⏳ Testler çalıştırılıyor...[/]")
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
+        env["PYTHONUTF8"]       = "1"
+
+        result = subprocess.run(
+            ["python", runner_file],
+            capture_output=True, text=True, timeout=15,
+            encoding="utf-8", errors="replace", env=env,
+        )
+
+        output    = result.stdout.strip()
+        json_line = [l for l in output.split("\n") if l.startswith("RESULT_JSON:")]
+
+        if json_line:
+            stats = json.loads(json_line[0].replace("RESULT_JSON: ", ""))
+            table = Table(box=ROUNDED, title="🧪 Test Sonuçları")
+            table.add_column("Durum", style="bold")
+            table.add_column("Sayı",  justify="right")
+            table.add_row("[green]✅ Başarılı[/]",  f"[green]{stats['passed']}[/]")
+            table.add_row("[red]❌ Başarısız[/]", f"[red]{stats['failed']}[/]")
+            console.print(table)
+
+            if stats["errors"]:
+                console.print("\n[error]Detaylar:[/]")
+                for err in stats["errors"]:
+                    console.print(f"  [dim]• {err}[/]")
+
+            if stats["failed"] == 0 and stats["passed"] > 0:
+                show_success("Tüm testler geçti! 🎉")
+                console.print(f"[info]Devam: `pymulakat submit {question_id}`[/]")
+            else:
+                console.print("[warning]⚠️ Bazı testler başarısız oldu.[/]")
+        else:
+            console.print("[red]❌ Test çıktısı alınamadı.[/]")
+            if result.stderr:
+                console.print(f"[dim]{result.stderr[:200]}[/]")
+
+    except subprocess.TimeoutExpired:
+        show_error("Testler zaman aşımına uğradı (15sn). Sonsuz döngü var mı?")
+    except Exception as e:
+        show_error(f"Test çalıştırma hatası: {e}")
+    finally:
+        if runner_file and Path(runner_file).exists():
+            try:
+                Path(runner_file).unlink()
+            except OSError:
+                pass
+        console.print("[dim]🧹 Geçici dosyalar temizlendi.[/]")
+
+
+@cli.command("get")
+@click.argument("question_id")
+@click.option("-l", "--lib", required=True, help="Kütüphane adı (zorunlu)")
+@require_login
+def get_question(question_id: str, lib: str):
+    """🔍 Belirli bir sorunun detaylarını görüntüle"""
+    show_header(f"📝 Soru #{question_id}", f"Kategori: {lib}")
+    data = api_request("GET", f"/interviews/{lib}/{question_id}")
+    console.print(Panel(
+        Markdown(data.get("question", data.get("description", "Açıklama yok"))),
+        title="🎯 Görev", border_style="blue"
+    ))
+    meta_table = Table(show_header=False, box=None, padding=(0, 1))
+    meta_table.add_row("[accent]Zorluk:[/]", data.get("difficulty", "Belirtilmemiş"))
+    meta_table.add_row("[accent]Konu:[/]",   data.get("topic",      "Belirtilmemiş"))
+    console.print(meta_table)
+    if data.get("hints"):
+        console.print("\n[info]💡 İpuçları:[/]")
+        for i, hint in enumerate(data["hints"], 1):
+            console.print(f"  [secondary]{i}.[/] {hint}")
+
+
+@cli.command("download")
+@click.option("-l", "--lib", default=None, help="Kütüphane filtresi")
+@require_login
+def download_interactive(lib: Optional[str]):
+    """📥 Soru listesinden seçim yap ve indir"""
+    show_header("📥 Soru Seçimi ve İndirme", "Listeden seçim yapın")
+
+    params = {"lib": lib} if lib else {}
+    try:
+        data = api_request("GET", "/interviews/", params=params)
+    except SystemExit:
+        return
+
+    if not data:
+        show_error("Bu kriterlerde soru bulunamadı.")
+        return
+
+    console.print("[info]📋 Mevcut Sorular:[/]")
+    table = Table(box=ROUNDED, show_header=True, header_style="bold blue", show_lines=True)
+    table.add_column("#",          style="cyan",    width=4)
+    table.add_column("ID",         style="dim",     width=6)
+    table.add_column("Konu",       style="white")
+    table.add_column("Kütüphane",  style="magenta")
+    table.add_column("Zorluk",     style="yellow")
+    for i, item in enumerate(data, 1):
+        table.add_row(
+            str(i), item["id"],
+            item.get("topic", "Başlıksız"),
+            item.get("lib", "unknown"),
+            item.get("level", item.get("difficulty", "-")),
+        )
+    console.print(table)
+
+    max_idx = len(data)
+    choice  = click.prompt(f"\n📌 İndirmek istediğiniz sorunun numarası (1-{max_idx})", type=int)
+    if not (1 <= choice <= max_idx):
+        show_error("Geçersiz seçim!")
+        return
+
+    selected    = data[choice - 1]
+    q_id        = selected["id"]
+    q_lib       = selected["lib"]
+    output_file = get_next_solution_filename()
+
+    console.print(f"\n[info]⬇️  İndiriliyor: {q_lib.upper()} / #{q_id}[/]")
+    with Progress(SpinnerColumn(), TextColumn("[primary]Kodlar hazırlanıyor...[/]"), console=console) as p:
+        p.add_task("", total=None)
+        resp = api_request("GET", f"/interviews/download/{q_lib}/{q_id}")
+
+    perms = load_permission_config()
+
+    # Starter code
+    if resp.get("starter_encoded"):
+        starter = decode_base64_content(resp["starter_encoded"])
+        try:
+            _atomic_write(Path(output_file), starter)
+            _set_mode(Path(output_file), perms["solution_file"])
+            console.print(f"[success]✓[/] Çözüm dosyası: [cyan]{Path(output_file).resolve()}[/]")
+        except (PermissionError, OSError) as e:
+            show_error(str(e), "Dosya Yazılamadı")
+            return
+
+    # Gizli test dosyası
+    if resp.get("test_encoded"):
+        tests     = decode_base64_content(resp["test_encoded"])
+        test_path = Path(f".test_{q_id}.py")
+        try:
+            _atomic_write(test_path, tests)
+            _set_mode(test_path, perms["test_file"])
+        except (PermissionError, OSError) as e:
+            show_error(str(e), "Test Dosyası Yazılamadı")
+            return
+
+    try:
+        save_interview_meta(q_id, q_lib, selected.get("topic", ""), output_file)
+        console.print("[dim]📌 Meta verisi kaydedildi.[/]")
+    except (PermissionError, OSError) as e:
+        console.print(f"[warning]⚠️  Meta kaydedilemedi: {e}[/]")
+
+    try:
+        subprocess.Popen(["code", output_file], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        console.print(f"[success]✓[/] VSCode açılıyor: [cyan]{output_file}[/]")
+    except FileNotFoundError:
+        console.print("[dim]💡 VSCode bulunamadı, dosyayı manuel açabilirsiniz.[/]")
+
+    console.print(Panel(
+        "[info]📌 Sonraki Adımlar:[/]\n"
+        f"  1. [cyan]{output_file}[/] dosyasını düzenle\n"
+        f"  2. Lokal test:      [cyan]pymulakat test {q_id}[/]\n"
+        f"  3. Sunucuya gönder: [cyan]pymulakat submit {q_id}[/]",
+        title="🚀 Devam Et", border_style="green"
+    ))
+
+
+# ═══════════════════════════════════════════════════════════
+# 📈 PROGRESS KOMUTU
+# ═══════════════════════════════════════════════════════════
+
+@cli.command("progress")
+@click.option("-l", "--lib",  required=True, help="Kütüphane adı")
+@click.option("-j", "--json", "as_json", is_flag=True, help="JSON formatında çıktı")
+@require_login
+def show_progress(lib: str, as_json: bool):
+    """📈 Kullanıcı ilerleme durumunu görüntüle"""
+    show_header("📈 İlerleme Raporu", f"Kategori: {lib.upper()}")
+    data = api_request("GET", "/auth/my-progress", params={"lib": lib})
+
+    if as_json:
+        console.print_json(json.dumps(data, indent=2, ensure_ascii=False))
+        return
+
+    summary = Table(box=ROUNDED, show_header=False)
+    summary.add_row("[accent]📦 Toplam Soru:[/]", f"[bold]{data.get('total', 0)}[/]")
+    completed = data.get("completed", [])
+    summary.add_row("[success]✅ Çözülen:[/]", f"[bold green]{len(completed)}[/]")
+    if completed:
+        accuracy = len(completed) / data.get("total", 1) * 100
+        summary.add_row("[info]🎯 Başarı Oranı:[/]", f"[bold cyan]{accuracy:.1f}%[/]")
+    console.print(summary)
+
+    if completed:
+        console.print("\n[info]🔹 Tamamlanan Sorular:[/]")
+        for item in completed:
+            attempt  = item.get("attempt", {})
+            time_str = _format_duration(attempt.get("time_taken", 0))
+            points   = attempt.get("points_gained", 0)
+            console.print(
+                f"  [success]✓[/] [cyan]#{item['id']}[/] {item.get('topic')} "
+                f"[secondary]→[/] ⏱️ {time_str} | 🏆 +{points} puan"
+            )
+
+
+# ═══════════════════════════════════════════════════════════
+# 🔧 HELPER FONKSIYONLAR
+# ═══════════════════════════════════════════════════════════
+
+def _get_user_id_from_token() -> Optional[str]:
+    import jwt
+    token = get_token()
+    if not token:
+        return None
+    try:
+        payload = jwt.decode(token, options={"verify_signature": False})
+        return payload.get("sub")
+    except Exception:
+        return None
+
+
+def _format_duration(seconds: float) -> str:
+    s = int(seconds or 0)
+    h, remainder = divmod(s, 3600)
+    m, sec       = divmod(remainder, 60)
+    if h: return f"{h}sa {m}dk"
+    if m: return f"{m}dk {sec}sn"
+    return f"{sec}sn"
+
+
+# ═══════════════════════════════════════════════════════════
+# 🚀 ENTRY POINT
+# ═══════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    console.print(Panel.fit(
+        "[bold primary]🎓 PyMulakat CLI[/] [secondary]v1.0.0[/]\n"
+        "[dim]Profesyonel Python Mülakat Platformu[/]",
+        box=ROUNDED, border_style="blue"
+    ))
+    if not check_interpreter("python"):
+        console.print("[warning]⚠ Bazı komutlar çalışmayabilir.[/]")
+    console.print()
+    cli(obj={})

pymulakat-1.0.0/src/pymulakat.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pymulakat
+Version: 1.0.0
+Summary: Profesyonel Python Mülakat Platformu CLI
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Requires-Dist: requests>=2.28
+Requires-Dist: PyJWT>=2.0

pymulakat-1.0.0/src/pymulakat.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/pymulakat/__init__.py
+src/pymulakat/main.py
+src/pymulakat.egg-info/PKG-INFO
+src/pymulakat.egg-info/SOURCES.txt
+src/pymulakat.egg-info/dependency_links.txt
+src/pymulakat.egg-info/entry_points.txt
+src/pymulakat.egg-info/requires.txt
+src/pymulakat.egg-info/top_level.txt

pymulakat-1.0.0/src/pymulakat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pymulakat-1.0.0/src/pymulakat.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pymulakat = pymulakat.main:cli

pymulakat-1.0.0/src/pymulakat.egg-info/requires.txt

@@ -0,0 +1,4 @@
+click>=8.0
+rich>=13.0
+requests>=2.28
+PyJWT>=2.0

pymulakat-1.0.0/src/pymulakat.egg-info/top_level.txt

@@ -0,0 +1 @@
+pymulakat