The OSINT investigator's workbench. One case, one folder, every tool. Local-first: your media and your investigations never leave your machine.
JavaScript
"""Derived temporal rows: Claims, media metadata and rebuild semantics."""
import pytest
from azimut.engine import timeline
from azimut.sqlite_backend import SqliteCase, convert_json_to_sqlite
from azimut.workspace import CaseError
def test_a_dated_claim_keeps_raw_syntax_and_normalized_bounds():
rows = timeline.project_entity(
{
"id": "e_claim",
"type": "claim",
"label": "A vehicle was present",
"attrs": {
"when": "2026-08~",
"time_role": "observed",
"confidence": "probable",
},
"provenance": {
"by": "user",
"at": "2026-08-11T10:00:00Z",
"status": "confirmed",
},
}
)
assert [row.id for row in rows] == ["temporal:claim:e_claim"]
assert rows[0].raw == "2026-08~"
assert rows[0].earliest == "2026-08-01T00:00:00.000000Z"
assert rows[0].latest == "2026-09-01T00:00:00.000000Z"
assert rows[0].approximate is True
assert rows[0].time_role == "observed"
def test_an_undated_claim_is_projected_for_the_undated_group():
row = timeline.project_entity(
{
"id": "e_claim",
"type": "claim",
"attrs": {},
"provenance": {"status": "suggested", "at": "2026-08-11T10:00:00Z"},
}
)[0]
assert row.raw is None
assert row.earliest is None
assert row.sortable is False
assert row.status == "suggested"
def test_a_local_media_time_is_known_but_not_invented_on_the_utc_axis():
row = timeline.project_media(
{"taken_at": "2021-04-24T14:52:29"},
"e_media",
)[0]
assert row.raw == "2021-04-24T14:52:29"
assert row.zone == "local"
assert row.earliest is None
assert row.sortable is False
def test_a_dated_proof_states_when_its_material_was_taken():
rows = timeline.project_entity(
{
"id": "e_proof",
"type": "proof",
"label": "Kharkiv strike proof",
"attrs": {"spec": "proofs/.meta/p.json", "when": "2024-03-11~"},
"provenance": {"by": "proof-composer", "at": "2026-08-11T10:00:00Z"},
}
)
by_kind = {row.kind: row for row in rows}
# The filing row stays: when the proof was made and when the footage was shot
# are two answers, and the second one replacing the first would lose a date.
assert set(by_kind) == {"filed", "taken"}
taken = by_kind["taken"]
assert taken.category == "statement"
assert taken.authority == "entity"
assert taken.raw == "2024-03-11~"
assert taken.approximate is True
assert taken.time_role == "occurred"
def test_an_undated_proof_reaches_the_timeline_only_as_a_filing():
rows = timeline.project_entity(
{
"id": "e_proof",
"type": "proof",
"attrs": {"spec": "proofs/.meta/p.json", "when": ""},
"provenance": {"at": "2026-08-11T10:00:00Z"},
}
)
assert [row.kind for row in rows] == ["filed"]
def test_media_dates_keep_world_time_separate_from_case_activity():
rows = timeline.project_media(
{
"taken_at": "2024-02-03T10:11:12Z",
"added_at": "2026-08-11T10:00:00Z",
"source": {
"upload_date": "20240204",
"imagery_date": "2024-02",
"fetched_at": "2026-08-11T09:59:00+00:00",
},
},
"e_media",
)
by_kind = {row.kind: row for row in rows}
assert by_kind["captured"].category == "media"
assert by_kind["published"].raw == "2024-02-04"
assert by_kind["imagery"].category == "media"
assert by_kind["collected"].category == "case_activity"
assert by_kind["added"].category == "case_activity"
def test_a_picture_of_two_moments_projects_two_dates_and_an_estimate_stays_one():
rows = timeline.project_media(
{
"source": {
"imagery_date": "2021-06",
"imagery_exact": False,
"imagery_a": "2024-05-03",
"imagery_a_exact": False,
"imagery_b": "2026-09-02T05:42:10Z",
},
},
"e_media",
)
by_kind = {row.kind: row for row in rows}
assert by_kind["imagery"].raw == "2021-06~" and by_kind["imagery"].approximate
assert by_kind["imagery-a"].raw == "2024-05-03~"
assert by_kind["imagery-b"].raw == "2026-09-02T05:42:10Z"
assert not by_kind["imagery-b"].approximate
assert {row.category for row in rows} == {"media"}
# two instants, not a range: neither row claims the time between them
assert {row.shape for row in rows} == {"instant"}
def test_old_malformed_time_stays_visible_without_blocking_a_rebuild():
row = timeline.project_entity(
{
"id": "e_old",
"type": "claim",
"attrs": {"when": "late summer"},
"provenance": {"at": "2026-08-11T10:00:00Z", "status": "confirmed"},
}
)[0]
assert row.raw == "late summer"
assert row.earliest is None
assert row.parse_error
def test_large_projection_stays_bounded_and_pages_without_duplicates(tmp_path):
store = SqliteCase.create(tmp_path / "case.db", name="Large timeline")
for index in range(205):
store.add_entity(
"claim",
f"Event {index:03d}",
{"when": f"2026-{index % 12 + 1:02d}-{index % 28 + 1:02d}"},
by="user",
)
labels = []
cursor = None
while True:
page = store.timeline_page(
categories=["statement"], limit=37, cursor=cursor, bucket="year"
)
labels.extend(item["label"] for item in page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
assert len(labels) == 205
assert len(set(labels)) == 205
assert page["total"] == 205
assert page["buckets"] == [
{
"start": "2026",
"count": 205,
"categories": {"statement": 205},
"first": "2026-01-01T00:00:00.000000Z",
"last": "2026-12-29T00:00:00.000000Z",
}
]
def _lopsided_case(tmp_path):
"""230 rows in January and 40 in July: a page off the front never reaches July."""
store = SqliteCase.create(tmp_path / "case.db", name="Lopsided timeline")
for index in range(230):
store.add_entity(
"claim", f"Jan {index:03d}", {"when": f"2026-01-{index % 28 + 1:02d}"}, by="user"
)
for index in range(40):
store.add_entity(
"claim", f"Jul {index:03d}", {"when": f"2026-07-{index % 28 + 1:02d}"}, by="user"
)
return store
def test_a_spread_page_samples_the_whole_window_where_a_plain_one_takes_its_front(tmp_path):
store = _lopsided_case(tmp_path)
front = store.timeline_page(categories=["statement"], limit=100)
spread = store.timeline_page(categories=["statement"], limit=100, spread=True)
assert front["total"] == spread["total"] == 270
assert {item["earliest"][:7] for item in front["items"]} == {"2026-01"}
# 270 rows over a 100-row page is one row in three, so the sample keeps January's
# share of the case rather than flattening it into July's.
assert len(spread["items"]) == 90
assert {item["earliest"][:7] for item in spread["items"]} == {"2026-01", "2026-07"}
assert sum(item["earliest"][:7] == "2026-07" for item in spread["items"]) == 13
def test_spread_pages_partition_the_window_without_a_repeat_or_a_gap(tmp_path):
store = _lopsided_case(tmp_path)
labels = []
pages = 0
cursor = None
while True:
page = store.timeline_page(
categories=["statement"], limit=100, cursor=cursor, spread=True
)
labels.extend(item["label"] for item in page["items"])
pages += 1
cursor = page["next_cursor"]
if cursor is None:
break
assert pages == 3
assert len(labels) == len(set(labels)) == 270
def test_a_window_that_fits_the_limit_is_served_whole_and_asks_for_nothing_more(tmp_path):
store = _lopsided_case(tmp_path)
page = store.timeline_page(
categories=["statement"], limit=200, spread=True, since="2026-07"
)
# Under the limit there is nothing to sample, so the window arrives in one page.
assert page["total"] == 40
assert len(page["items"]) == 40
assert page["next_cursor"] is None
def test_a_cursor_from_the_other_kind_of_read_is_refused(tmp_path):
store = _lopsided_case(tmp_path)
front = store.timeline_page(categories=["statement"], limit=100)
spread = store.timeline_page(categories=["statement"], limit=100, spread=True)
with pytest.raises(CaseError):
store.timeline_page(
categories=["statement"], limit=100, cursor=front["next_cursor"], spread=True
)
with pytest.raises(CaseError):
store.timeline_page(categories=["statement"], limit=100, cursor=spread["next_cursor"])
def test_json_conversion_builds_the_projection_with_the_graph(tmp_path):
db = tmp_path / "case.db"
convert_json_to_sqlite(
{
"name": "Legacy",
"created_at": "2026-01-01T00:00:00Z",
"updated_at": "2026-01-02T00:00:00Z",
"folders": [],
"links": [],
"entities": [
{
"id": "e_claim",
"type": "claim",
"label": "Existing observation",
"attrs": {"when": "2026-08"},
"provenance": {
"by": "user",
"at": "2026-08-11T10:00:00Z",
"status": "confirmed",
},
}
],
},
db,
)
item = SqliteCase.open(db).timeline_page(categories=["statement"])["items"][0]
assert item["owner_id"] == "e_claim"
assert item["earliest"] == "2026-08-01T00:00:00.000000Z"