BibexPy 2.0.0__py3-none-any.whl

bibexpy/_server/routers/audit.py

@@ -0,0 +1,65 @@
+"""Audit log endpoint'leri."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import PlainTextResponse
+from pydantic import BaseModel
+from typing import Any, Optional
+
+from services import analyses, audit, storage
+
+
+router = APIRouter(prefix="/projects/{project_id}/audit", tags=["audit"])
+
+
+class AuditEntry(BaseModel):
+    kind: str
+    title: str
+    details: Optional[dict[str, Any]] = None
+    user_action: Optional[str] = None
+
+
+@router.get("")
+def list_entries(project_id: str, limit: int = 200):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    # Aktif analizin geçmişi (+ proje-seviye kurulum) — her analizin AYRI geçmişi.
+    active = analyses.get_active_analysis_id(project_id)
+    return audit.read(project_id, limit=limit, analysis_id=active)
+
+
+@router.get("/summary")
+def get_summary(project_id: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    return audit.summary(project_id)
+
+
+@router.post("")
+def add_entry(project_id: str, payload: AuditEntry):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    return audit.write(
+        project_id,
+        kind=payload.kind,
+        title=payload.title,
+        details=payload.details,
+        user_action=payload.user_action,
+    )
+
+
+@router.delete("", status_code=204)
+def clear_entries(project_id: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    audit.clear(project_id)
+    return None
+
+
+@router.get("/report.md", response_class=PlainTextResponse)
+def markdown_report(project_id: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    active = analyses.get_active_analysis_id(project_id)
+    return audit.format_markdown_report(project_id, analysis_id=active)

bibexpy/_server/routers/convert.py

@@ -0,0 +1,101 @@
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+from services import audit, converter, storage
+
+router = APIRouter(prefix="/projects/{project_id}/convert", tags=["convert"])
+
+
+class ConvertCsvRequest(BaseModel):
+    files: list[str]
+    output: str = "scopus_merged.xlsx"
+
+
+class ConvertWosRequest(BaseModel):
+    files: list[str]
+    output: str = "wos_merged.xlsx"
+
+
+class ConvertXlsxRequest(BaseModel):
+    file: str
+    output: str | None = None
+
+
+class ConvertResult(BaseModel):
+    name: str
+    size: int
+    relative_path: str
+
+
+def _result(path: Path) -> ConvertResult:
+    return ConvertResult(
+        name=path.name,
+        size=path.stat().st_size,
+        relative_path=str(path.relative_to(storage.settings.storage_path)),
+    )
+
+
+@router.get("/processed", response_model=list[ConvertResult])
+def list_processed(project_id: str):
+    return converter.list_processed(project_id)
+
+
+def _audit_convert(project_id: str, kind: str, inputs: list[str] | str, output: Path) -> None:
+    audit.write(
+        project_id,
+        kind="convert",
+        title=f"{kind}: {output.name}",
+        title_key="audit.titles.converted",
+        title_params={"name": output.name},
+        analysis_id=None,  # proje-seviye tool
+        details={
+            "type": kind,
+            "inputs": inputs if isinstance(inputs, list) else [inputs],
+            "output": output.name,
+            "output_size": output.stat().st_size,
+        },
+        user_action="convert",
+    )
+
+
+@router.post("/csv-to-xlsx", response_model=ConvertResult)
+def csv_to_xlsx(project_id: str, payload: ConvertCsvRequest):
+    p = converter.csv_to_xlsx(project_id, payload.files, payload.output)
+    _audit_convert(project_id, "Scopus CSV → XLSX", payload.files, p)
+    return _result(p)
+
+
+@router.post("/wos-to-xlsx", response_model=ConvertResult)
+def wos_to_xlsx(project_id: str, payload: ConvertWosRequest):
+    p = converter.wos_to_xlsx(project_id, payload.files, payload.output)
+    _audit_convert(project_id, "WoS TXT → XLSX", payload.files, p)
+    return _result(p)
+
+
+@router.post("/xlsx-to-wos-txt", response_model=ConvertResult)
+def xlsx_to_wos_txt(project_id: str, payload: ConvertXlsxRequest):
+    p = converter.xlsx_to_wos_txt(project_id, payload.file, payload.output)
+    _audit_convert(project_id, "XLSX → WoS TXT", payload.file, p)
+    return _result(p)
+
+
+@router.post("/xlsx-to-tsv", response_model=ConvertResult)
+def xlsx_to_tsv(project_id: str, payload: ConvertXlsxRequest):
+    p = converter.xlsx_to_tsv(project_id, payload.file, payload.output)
+    _audit_convert(project_id, "XLSX → TSV", payload.file, p)
+    return _result(p)
+
+
+@router.get("/download/{filename}")
+def download(project_id: str, filename: str):
+    meta = storage.get_project(project_id)
+    if meta is None:
+        raise HTTPException(404, "project_not_found")
+    name = Path(filename).name
+    target = storage.project_dir(project_id) / "processed" / name
+    if not target.exists() or not target.is_file():
+        raise HTTPException(404, "file_not_found")
+    return FileResponse(target, filename=name)

bibexpy/_server/routers/disambiguate.py

@@ -0,0 +1,177 @@
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from config import settings
+from jobs.runner import job_runner
+from services import audit, storage
+from services.disambiguation import pipeline
+
+router = APIRouter(prefix="/projects/{project_id}/disambiguate", tags=["disambiguate"])
+
+
+@router.get("/status")
+def status(project_id: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    return {
+        "enabled": settings.disambiguation_enabled,
+        "configured": bool(settings.effective_llm_api_key),
+        "model": settings.effective_llm_model,
+        "provider": settings.llm_provider or "deepseek",
+        "base_url": settings.effective_llm_base_url,
+        "blocking_threshold": settings.disambiguation_blocking_threshold,
+        "auto_approve_threshold": settings.disambiguation_auto_approve_threshold,
+    }
+
+
+class DisambiguateRequest(BaseModel):
+    # `mode` geriye uyumluluk için durur; artık davranışı etkilemez (3-katman varsayılan).
+    mode: str = "auto"
+    # Opsiyonel maliyet/test sınırı — sadece ilk N kayıt taranır. None = tüm dataset.
+    max_records: int | None = None
+
+
+@router.post("/authors")
+async def start_authors(project_id: str, payload: DisambiguateRequest | None = None):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if not settings.disambiguation_enabled:
+        raise HTTPException(400, "disambiguation_disabled_hint")
+    max_records = payload.max_records if payload else None
+
+    async def worker(ctx):
+        return await pipeline.run_author_disambiguation(ctx, project_id, max_records=max_records)
+
+    job = job_runner.submit(
+        project_id, "disambiguate_authors", "Yazar Ayrıştırma",
+        worker, title_key="audit.titles.authorDisambiguation", exclusive=True,
+    )
+    return {"job_id": job.id, "max_records": max_records}
+
+
+@router.post("/affiliations")
+async def start_affiliations(project_id: str, payload: DisambiguateRequest | None = None):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if not settings.disambiguation_enabled:
+        raise HTTPException(400, "disambiguation_disabled")
+    max_records = payload.max_records if payload else None
+
+    async def worker(ctx):
+        return await pipeline.run_affiliation_disambiguation(ctx, project_id, max_records=max_records)
+
+    job = job_runner.submit(
+        project_id, "disambiguate_affiliations", "Kurum Normalizasyonu",
+        worker, title_key="audit.titles.affiliationStandardization", exclusive=True,
+    )
+    return {"job_id": job.id}
+
+
+@router.post("/countries")
+async def start_countries(project_id: str, payload: DisambiguateRequest | None = None):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if not settings.disambiguation_enabled:
+        raise HTTPException(400, "disambiguation_disabled")
+    max_records = payload.max_records if payload else None
+
+    async def worker(ctx):
+        return await pipeline.run_country_standardization(ctx, project_id, max_records=max_records)
+
+    job = job_runner.submit(
+        project_id, "disambiguate", "Ülke Standartlaştırma",
+        worker, title_key="audit.titles.countryStandardization", exclusive=True,
+    )
+    return {"job_id": job.id}
+
+
+@router.post("/organizations")
+async def start_organizations(project_id: str, payload: DisambiguateRequest | None = None):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if not settings.disambiguation_enabled:
+        raise HTTPException(400, "disambiguation_disabled")
+    max_records = payload.max_records if payload else None
+
+    async def worker(ctx):
+        return await pipeline.run_org_rollup(ctx, project_id, max_records=max_records)
+
+    job = job_runner.submit(
+        project_id, "disambiguate", "Kurum Toplama (üst kurum)",
+        worker, title_key="audit.titles.orgRollup", exclusive=True,
+    )
+    return {"job_id": job.id}
+
+
+@router.get("/proposals/{kind}")
+def get_proposals(project_id: str, kind: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if kind not in ("authors", "affiliations", "countries", "organizations"):
+        raise HTTPException(400, "invalid_kind")
+    return pipeline.list_proposals(project_id, kind)
+
+
+class ApplyRequest(BaseModel):
+    kind: str
+    approved: list[dict[str, Any]] = []          # birleştirme (merge) onayları
+    approved_splits: list[dict[str, Any]] = []   # ayrıştırma (split) onayları — yalnız authors
+
+
+@router.post("/apply")
+def apply(project_id: str, payload: ApplyRequest):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if payload.kind not in ("authors", "affiliations", "countries", "organizations"):
+        raise HTTPException(400, "invalid_kind")
+
+    # Önce AYRIŞTIRMA (split), sonra BİRLEŞTİRME (merge) — sıra: ayrıştırma ilk işlem.
+    split_result = None
+    if payload.kind == "authors" and payload.approved_splits:
+        split_result = pipeline.apply_splits(project_id, payload.approved_splits)
+    merge_result = None
+    if payload.approved:
+        merge_result = pipeline.apply_clusters(project_id, payload.kind, payload.approved)
+
+    replacements = (
+        (split_result or {}).get("replacements", 0) + (merge_result or {}).get("replacements", 0)
+    )
+    snapshot = (merge_result or {}).get("snapshot") or (split_result or {}).get("snapshot")
+    audit.write(
+        project_id,
+        kind="disambiguate",
+        title=f"Yazar Ayrıştırma uygulandı ({payload.kind}) — {replacements} değişiklik",
+        title_key="audit.titles.disambiguationApplied",
+        title_params={"kind": payload.kind, "n": replacements},
+        details={
+            "kind": payload.kind,
+            "clusters_approved": len(payload.approved),
+            "splits_approved": len(payload.approved_splits),
+            "replacements": replacements,
+        },
+        snapshot=snapshot,
+        user_action="apply_disambiguation",
+    )
+    return {"merge": merge_result, "split": split_result, "replacements": replacements, "snapshot": snapshot}
+
+
+class RestoreRequest(BaseModel):
+    snapshot: str
+
+
+@router.post("/restore")
+def restore(project_id: str, payload: RestoreRequest):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    result = pipeline.restore_snapshot(project_id, payload.snapshot)
+    audit.write(
+        project_id,
+        kind="snapshot_restore",
+        title=f"Disambiguation snapshot geri yüklendi",
+        title_key="audit.titles.disambiguationRestored",
+        details={"snapshot": payload.snapshot, "into": result.get("into")},
+        user_action="restore",
+    )
+    return result

bibexpy/_server/routers/downloads.py

@@ -0,0 +1,26 @@
+"""Üretilen dosyalar için genel indirme endpoint'i."""
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from services import storage
+
+router = APIRouter(prefix="/projects/{project_id}/download", tags=["downloads"])
+
+# İndirilebilir alt klasörler. analyses/ direkt değil, alt klasörleri ile gelir (frontend gerekirse path bildirir).
+ALLOWED = {"raw", "processed", "merged", "exports", "snapshots"}
+
+
+@router.get("/{folder}/{filename}")
+def download(project_id: str, folder: str, filename: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    if folder not in ALLOWED:
+        raise HTTPException(400, f"invalid_folder: {folder}")
+    name = Path(filename).name
+    target = storage.project_dir(project_id) / folder / name
+    if not target.exists() or not target.is_file():
+        raise HTTPException(404, "file_not_found")
+    return FileResponse(target, filename=name)

bibexpy/_server/routers/enrich.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from jobs.runner import job_runner
+from services import enricher, storage
+
+router = APIRouter(prefix="/projects/{project_id}/enrich", tags=["enrich"])
+
+
+class ApiEnrichRequest(BaseModel):
+    sources: list[str] | None = None  # ileride seçimli kullanmak için
+
+
+@router.post("/fill-all")
+async def start_fill_all(project_id: str):
+    """Birleşik doldurma: DOI başına tek API çağrısı, tüm boş alanlar (yalnız API; ML yoktur)."""
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+
+    async def worker(ctx):
+        return await enricher.run_fill_all(ctx, project_id)
+
+    job = job_runner.submit(
+        project_id, "enrich_api", "Eksik alanları doldur (API)", worker,
+        title_key="audit.titles.fillAll", exclusive=True,
+    )
+    return {"job_id": job.id}
+
+
+@router.post("/api")
+async def start_api_enrichment(project_id: str, payload: ApiEnrichRequest):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+
+    async def worker(ctx):
+        return await enricher.run_api_enrichment(ctx, project_id, payload.sources)
+
+    job = job_runner.submit(
+        project_id, "enrich_api", "API ile zenginleştirme", worker,
+        title_key="audit.titles.apiEnrichment", exclusive=True,
+    )
+    return {"job_id": job.id}

bibexpy/_server/routers/export.py

@@ -0,0 +1,116 @@
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from services import audit, exporter, storage
+
+router = APIRouter(prefix="/projects/{project_id}/export", tags=["export"])
+
+
+class ExportRequest(BaseModel):
+    fmt: str
+    filter: Optional[dict[str, Any]] = None
+    output_name: Optional[str] = None
+    # "rename" (default) → yeni timestamp'li dosya, eskiler kalır
+    # "replace"          → aynı format'taki tüm eski dosyalar silinir, yenisi yazılır
+    # "abort"            → aynı format zaten varsa hata fırlat (409)
+    if_exists: str = "rename"
+
+
+class ExportResult(BaseModel):
+    name: str
+    size: int
+    relative_path: str
+
+
+def _list_format_files(project_id: str, fmt: str) -> list[Path]:
+    """Aynı format'taki mevcut export dosyalarını döner."""
+    root = storage.project_dir(project_id)
+    exports_dir = root / "exports"
+    if not exports_dir.exists():
+        return []
+    suffix = f".{fmt.lower()}"
+    return [f for f in exports_dir.iterdir() if f.is_file() and f.suffix.lower() == suffix]
+
+
+@router.get("", response_model=list[ExportResult])
+def list_exports(project_id: str):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    return exporter.list_exports(project_id)
+
+
+@router.post("", response_model=ExportResult)
+def create_export(project_id: str, payload: ExportRequest):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+
+    # Aynı format için mevcut dosyaları if_exists'e göre ele al
+    if_exists = (payload.if_exists or "rename").lower()
+    if if_exists not in ("rename", "replace", "abort"):
+        raise HTTPException(400, "invalid_if_exists")
+
+    existing = _list_format_files(project_id, payload.fmt)
+    replaced_count = 0
+    if existing:
+        if if_exists == "abort":
+            raise HTTPException(409, f"format_files_exist: {len(existing)}")
+        if if_exists == "replace":
+            for f in existing:
+                try:
+                    f.unlink()
+                    replaced_count += 1
+                except Exception:
+                    pass
+
+    p = exporter.export(project_id, payload.fmt, payload.filter, payload.output_name)
+    filtered = bool(payload.filter)
+    audit.write(
+        project_id,
+        kind="export",
+        title=f"Export ({payload.fmt.upper()}): {p.name}",
+        title_key="audit.titles.exported",
+        title_params={"fmt": payload.fmt.upper(), "name": p.name},
+        details={
+            "format": payload.fmt,
+            "output": p.name,
+            "output_size": p.stat().st_size,
+            "filtered": filtered,
+            "filter_keys": list((payload.filter or {}).keys()) if filtered else [],
+            "if_exists": if_exists,
+            "replaced_count": replaced_count,
+        },
+        user_action="export",
+    )
+    return ExportResult(name=p.name, size=p.stat().st_size,
+                        relative_path=str(p.relative_to(storage.settings.storage_path)))
+
+
+@router.delete("/{name}")
+def delete_export(project_id: str, name: str):
+    """Belirli bir export dosyasını sil."""
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+    # Path-traversal koruması
+    safe_name = Path(name).name
+    if not safe_name or safe_name != name:
+        raise HTTPException(400, "invalid_filename")
+    target = storage.project_dir(project_id) / "exports" / safe_name
+    if not target.exists() or not target.is_file():
+        raise HTTPException(404, "file_not_found")
+    try:
+        target.unlink()
+    except Exception as e:
+        raise HTTPException(500, f"delete_failed: {e}")
+    audit.write(
+        project_id,
+        kind="export",
+        title=f"Export silindi: {safe_name}",
+        title_key="audit.titles.exportDeleted",
+        title_params={"name": safe_name},
+        details={"deleted": safe_name},
+        user_action="export_delete",
+    )
+    return {"ok": True, "deleted": safe_name}

bibexpy/_server/routers/export_folder.py

@@ -0,0 +1,97 @@
+"""Belirli bir lokal klasöre kopyalama — self-hosted için.
+
+Self-hosted tek kullanıcı senaryosunda backend ve kullanıcı aynı makinededir;
+backend'in yazma yetkisi olan herhangi bir klasöre çıktıyı bırakabilir.
+"""
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from services import audit, storage
+
+router = APIRouter(prefix="/projects/{project_id}/export-folder", tags=["export-folder"])
+
+
+class CopyRequest(BaseModel):
+    files: list[str]            # exports/ altındaki dosya adları
+    target_folder: str          # mutlak path (örn. C:\Users\me\Desktop\bibex_out)
+    create_if_missing: bool = True
+
+
+class CopyReport(BaseModel):
+    target_folder: str
+    copied: list[str]
+    skipped: list[dict[str, Any]]
+
+
+@router.post("", response_model=CopyReport)
+def copy_to_folder(project_id: str, payload: CopyRequest):
+    if storage.get_project(project_id) is None:
+        raise HTTPException(404, "project_not_found")
+
+    target = Path(payload.target_folder).expanduser()
+    if not target.is_absolute():
+        raise HTTPException(400, "target_folder_not_absolute")
+
+    if not target.exists():
+        if payload.create_if_missing:
+            try:
+                target.mkdir(parents=True, exist_ok=True)
+            except Exception as e:
+                raise HTTPException(400, f"folder_create_failed: {e}")
+        else:
+            raise HTTPException(400, "target_folder_missing")
+
+    exports = storage.project_dir(project_id) / "exports"
+    copied: list[str] = []
+    skipped: list[dict[str, Any]] = []
+
+    for name in payload.files:
+        name = Path(name).name  # safety
+        src = exports / name
+        if not src.exists():
+            skipped.append({"name": name, "reason": "Kaynak dosya bulunamadı"})
+            continue
+        dst = target / name
+        try:
+            shutil.copy2(src, dst)
+            copied.append(str(dst))
+        except Exception as e:
+            skipped.append({"name": name, "reason": str(e)})
+
+    audit.write(
+        project_id,
+        kind="export",
+        title=f"{len(copied)} dosya lokal klasöre kopyalandı",
+        title_key="audit.titles.filesCopiedToFolder",
+        title_params={"n": len(copied)},
+        details={
+            "target_folder": str(target),
+            "copied_count": len(copied),
+            "skipped_count": len(skipped),
+            "copied": copied,
+            "skipped": skipped,
+        },
+        user_action="copy_to_folder",
+    )
+    return CopyReport(target_folder=str(target), copied=copied, skipped=skipped)
+
+
+@router.get("/suggest", response_model=dict)
+def suggest_folders():
+    """Önerilen çıktı klasörleri — kullanıcının ev dizini altında."""
+    home = Path.home()
+    out = {
+        "home": str(home),
+        "suggestions": [
+            {"label": "İndirilenler", "path": str(home / "Downloads")},
+            {"label": "Belgeler", "path": str(home / "Documents")},
+            {"label": "Masaüstü", "path": str(home / "Desktop")},
+            {"label": "BibexPy çıktı", "path": str(home / "Documents" / "BibexPy")},
+        ],
+    }
+    return out