azimut 0.1.0__py3-none-any.whl

azimut/__init__.py

@@ -0,0 +1,3 @@
+"""Azimut — the OSINT investigator's workbench."""
+
+__version__ = "0.1.0"

azimut/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

azimut/api/cases.py

@@ -0,0 +1,237 @@
+"""REST API for case lifecycle, notes, entities and links."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from ..engine import media as media_engine
+from ..engine import satellite as satellite_engine
+from ..workspace import Case, CaseError
+
+router = APIRouter(prefix="/api/cases", tags=["cases"])
+
+
+def get_case(case_id: str) -> Case:
+    try:
+        return Case.open(case_id)
+    except CaseError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+def _ensure_name_free(name: str, *, exclude_id: str | None = None) -> None:
+    """Reject a case name already taken by another (non-scratch) case, matched
+    case-insensitively on the trimmed name. ``exclude_id`` lets a rename keep
+    its own name."""
+    wanted = name.strip().casefold()
+    for c in Case.list_all():
+        if c.get("scratch") or c["id"] == exclude_id:
+            continue
+        if str(c.get("name", "")).strip().casefold() == wanted:
+            raise HTTPException(status_code=409, detail=f"a case named '{name}' already exists")
+
+
+def _unlink_inside(case: Case, rel_path: str) -> None:
+    try:
+        case.resolve_inside(rel_path).unlink(missing_ok=True)
+    except CaseError:
+        pass
+
+
+class CreateCase(BaseModel):
+    name: str = Field(min_length=1, max_length=120)
+
+
+class PromoteCase(BaseModel):
+    name: str = Field(min_length=1, max_length=120)
+
+
+class Notes(BaseModel):
+    text: str
+
+
+class EntityIn(BaseModel):
+    type: str = Field(min_length=1, max_length=40)
+    label: str = Field(min_length=1, max_length=300)
+    attrs: dict[str, Any] = Field(default_factory=dict)
+    status: str = "confirmed"
+
+
+class EntityPatch(BaseModel):
+    type: str | None = None
+    label: str | None = None
+    attrs: dict[str, Any] | None = None
+    status: str | None = None
+
+
+class LinkIn(BaseModel):
+    from_id: str
+    to_id: str
+    type: str = Field(min_length=1, max_length=60)
+    status: str = "confirmed"
+
+
+class FolderIn(BaseModel):
+    name: str = Field(min_length=1, max_length=120)
+
+
+@router.get("")
+def list_cases() -> list[dict[str, Any]]:
+    return Case.list_all()
+
+
+@router.post("")
+def create_case(body: CreateCase) -> dict[str, Any]:
+    _ensure_name_free(body.name)
+    try:
+        case = Case.create(body.name)
+    except CaseError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    return {"id": case.id, **case.read()}
+
+
+@router.post("/scratch")
+def create_scratch() -> dict[str, Any]:
+    case = Case.create("Scratch session", scratch=True)
+    return {"id": case.id, **case.read()}
+
+
+@router.get("/{case_id}")
+def read_case(case_id: str) -> dict[str, Any]:
+    case = get_case(case_id)
+    return {"id": case.id, "scratch": case.is_scratch, **case.read()}
+
+
+@router.post("/{case_id}/promote")
+def promote_case(case_id: str, body: PromoteCase) -> dict[str, Any]:
+    case = get_case(case_id)
+    _ensure_name_free(body.name)
+    try:
+        promoted = case.promote(body.name)
+    except CaseError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+    return {"id": promoted.id, **promoted.read()}
+
+
+@router.patch("/{case_id}")
+def rename_case(case_id: str, body: CreateCase) -> dict[str, Any]:
+    case = get_case(case_id)
+    _ensure_name_free(body.name, exclude_id=case.id)
+    case.rename(body.name)
+    return {"id": case.id, **case.read()}
+
+
+@router.delete("/{case_id}")
+def delete_case(case_id: str) -> dict[str, str]:
+    get_case(case_id).delete()
+    return {"status": "deleted"}
+
+
+@router.get("/{case_id}/notes")
+def read_notes(case_id: str) -> dict[str, str]:
+    return {"text": get_case(case_id).read_notes()}
+
+
+@router.put("/{case_id}/notes")
+def write_notes(case_id: str, body: Notes) -> dict[str, str]:
+    get_case(case_id).write_notes(body.text)
+    return {"status": "saved"}
+
+
+@router.post("/{case_id}/entities")
+def add_entity(case_id: str, body: EntityIn) -> dict[str, Any]:
+    case = get_case(case_id)
+    return case.add_entity(
+        body.type, body.label, body.attrs, by="user", status=body.status  # type: ignore[arg-type]
+    )
+
+
+@router.patch("/{case_id}/entities/{entity_id}")
+def update_entity(case_id: str, entity_id: str, body: EntityPatch) -> dict[str, Any]:
+    case = get_case(case_id)
+    patch = {k: v for k, v in body.model_dump().items() if v is not None}
+    try:
+        return case.update_entity(entity_id, patch)
+    except CaseError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.delete("/{case_id}/entities/{entity_id}")
+def remove_entity(case_id: str, entity_id: str) -> dict[str, str]:
+    """Delete an entity and the on-disk artifact it stands for, so removing a
+    row in the sidebar deletes it everywhere it appears (spec §3.5)."""
+    case = get_case(case_id)
+    entity = next((e for e in case.read()["entities"] if e["id"] == entity_id), None)
+    if entity is None:
+        raise HTTPException(status_code=404, detail=f"entity '{entity_id}' not found")
+
+    etype = entity.get("type")
+    attrs = entity.get("attrs", {})
+
+    # media has its own delete that drops file + thumbnail + sidecar + entity
+    if etype == "media" and attrs.get("path"):
+        try:
+            media_engine.delete_media(case, attrs["path"])
+        except CaseError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"status": "deleted"}
+
+    # other artifact-backed types: drop the file(s) before removing the row.
+    # captures carry the image; a bare place (no path) has nothing on disk.
+    if etype in ("capture", "place") and attrs.get("path"):
+        satellite_engine.unlink_capture(case, attrs["path"])
+    elif etype == "proof" and attrs.get("spec"):
+        _unlink_inside(case, attrs["spec"])
+        _unlink_inside(case, attrs["spec"].removesuffix(".json") + ".png")
+    elif etype == "post" and attrs.get("draft"):
+        _unlink_inside(case, attrs["draft"])
+    elif etype == "inspect-session" and attrs.get("spec"):
+        _unlink_inside(case, attrs["spec"])
+
+    try:
+        case.remove_entity(entity_id)
+    except CaseError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    return {"status": "deleted"}
+
+
+@router.post("/{case_id}/links")
+def add_link(case_id: str, body: LinkIn) -> dict[str, Any]:
+    case = get_case(case_id)
+    try:
+        return case.add_link(
+            body.from_id, body.to_id, body.type, by="user", status=body.status  # type: ignore[arg-type]
+        )
+    except CaseError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.delete("/{case_id}/links/{link_id}")
+def remove_link(case_id: str, link_id: str) -> dict[str, str]:
+    try:
+        get_case(case_id).remove_link(link_id)
+    except CaseError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    return {"status": "deleted"}
+
+
+@router.get("/{case_id}/folders")
+def list_folders(case_id: str) -> list[str]:
+    return get_case(case_id).list_folders()
+
+
+@router.post("/{case_id}/folders")
+def add_folder(case_id: str, body: FolderIn) -> list[str]:
+    case = get_case(case_id)
+    try:
+        return case.add_folder(body.name)
+    except CaseError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+@router.delete("/{case_id}/folders")
+def remove_folder(case_id: str, name: str) -> list[str]:
+    return get_case(case_id).remove_folder(name)
+

azimut/api/drafts.py

@@ -0,0 +1,129 @@
+"""REST API for post drafts: save, list, load, delete.
+
+A draft is the re-editable state of the Post Composer (thread of tweets built
+from a geolocation). Drafts live in ``<case>/exports/`` as JSON and are indexed
+as ``post`` entities so they show up in the case sidebar (spec §4 — the case is
+the product). Azimut never posts on your behalf; a draft is prepared here and the
+human publishes it (spec §6 non-goals).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from ..workspace import CaseError
+from .cases import get_case
+
+router = APIRouter(prefix="/api", tags=["drafts"])
+
+DRAFT_MARKER = 1
+
+
+class DraftIn(BaseModel):
+    name: str | None = None  # slug; None → derived from title
+    title: str = Field(min_length=1, max_length=200)
+    state: dict[str, Any]  # opaque Post Composer state (fields + tweets)
+
+
+def _slug(text: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    return slug[:80] or "draft"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+@router.get("/cases/{case_id}/drafts")
+def list_drafts(case_id: str) -> list[dict[str, Any]]:
+    case = get_case(case_id)
+    drafts = []
+    for path in sorted(case.subdir("exports").glob("*.json")):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        if data.get("azimut_draft") != DRAFT_MARKER:
+            continue
+        drafts.append(
+            {
+                "name": path.stem,
+                "title": data.get("title", path.stem),
+                "updated_at": data.get("updated_at"),
+                "created_at": data.get("created_at"),
+            }
+        )
+    drafts.sort(key=lambda d: d.get("updated_at") or "", reverse=True)
+    return drafts
+
+
+@router.get("/cases/{case_id}/drafts/{name}")
+def load_draft(case_id: str, name: str) -> dict[str, Any]:
+    case = get_case(case_id)
+    try:
+        path = case.resolve_inside(f"exports/{name}.json")
+    except CaseError as exc:
+        raise HTTPException(status_code=403, detail=str(exc)) from exc
+    if not path.exists():
+        raise HTTPException(status_code=404, detail="draft not found")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+@router.post("/cases/{case_id}/drafts")
+def save_draft(case_id: str, body: DraftIn) -> dict[str, Any]:
+    case = get_case(case_id)
+    name = _slug(body.name or body.title)
+    exports_dir = case.subdir("exports")
+
+    path = exports_dir / f"{name}.json"
+    existing_created = None
+    if path.exists():
+        try:
+            existing_created = json.loads(path.read_text(encoding="utf-8")).get("created_at")
+        except (OSError, json.JSONDecodeError):
+            existing_created = None
+
+    data = {
+        "azimut_draft": DRAFT_MARKER,
+        "title": body.title,
+        "created_at": existing_created or _now(),
+        "updated_at": _now(),
+        "state": body.state,
+    }
+    path.write_text(
+        json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+
+    # upsert the post entity (analyst action → confirmed)
+    existing = case.find_entity(attr="draft", value=f"exports/{name}.json")
+    if existing:
+        case.update_entity(existing["id"], {"label": body.title})
+    else:
+        case.add_entity(
+            "post",
+            body.title,
+            attrs={"draft": f"exports/{name}.json"},
+            by="post-composer",
+        )
+
+    return {"name": name, "draft": f"exports/{name}.json"}
+
+
+@router.delete("/cases/{case_id}/drafts/{name}")
+def delete_draft(case_id: str, name: str) -> dict[str, str]:
+    case = get_case(case_id)
+    try:
+        path = case.resolve_inside(f"exports/{name}.json")
+    except CaseError as exc:
+        raise HTTPException(status_code=403, detail=str(exc)) from exc
+    path.unlink(missing_ok=True)
+    entity = case.find_entity(attr="draft", value=f"exports/{name}.json")
+    if entity:
+        case.remove_entity(entity["id"])
+    return {"status": "deleted"}

azimut/api/files.py

@@ -0,0 +1,27 @@
+"""Serve case files (media, thumbnails, satellite crops, proofs) to the UI.
+
+Only paths inside a case directory are reachable (Case.resolve_inside refuses
+traversal), and the server itself binds to localhost only.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from ..workspace import CaseError
+from .cases import get_case
+
+router = APIRouter(prefix="/files", tags=["files"])
+
+
+@router.get("/{case_id}/{rel_path:path}")
+def case_file(case_id: str, rel_path: str) -> FileResponse:
+    case = get_case(case_id)
+    try:
+        path = case.resolve_inside(rel_path)
+    except CaseError as exc:
+        raise HTTPException(status_code=403, detail=str(exc)) from exc
+    if not path.is_file():
+        raise HTTPException(status_code=404, detail="file not found")
+    return FileResponse(path)