lannotex 0.1.0__py3-none-any.whl

lannotex/exporters.py

@@ -0,0 +1,212 @@
+"""Local editable exports. No company approval or release status is implied."""
+from __future__ import annotations
+import csv
+import json
+from pathlib import Path
+import tempfile
+import uuid
+from . import __version__
+from .domain import Annotation, polygon_area, validate_all
+from .storage import Project, atomic_text
+
+
+def labelme_data(image_path, width, height, annotations, negative=False):
+    shapes = []
+    for a in annotations:
+        if a.kind == 'classification': continue
+        if a.kind == 'box':
+            x,y,r,b = a.geometry
+            points = [[x*width,y*height],[r*width,b*height]]
+        else: points = [[x*width,y*height] for x,y in a.geometry]
+        shapes.append({'label':a.label,'points':points,'shape_type':'rectangle' if a.kind=='box' else 'polygon',
+                       'flags':{},'group_id':None,'lannotex_id':a.id})
+    return {'version':'5.5.0','imageData':None,'imagePath':image_path,'imageWidth':width,'imageHeight':height,
+            'flags':{a.label:True for a in annotations if a.kind=='classification'}, 'shapes':shapes,
+            'lannotex':{'version':__version__,'no_targets':negative,'editable':True}}
+
+
+def labelme(path, image_path, width, height, annotations):
+    atomic_text(path,json.dumps(labelme_data(image_path,width,height,annotations),indent=2))
+
+
+def parse_labelme(data):
+    w,h = data['imageWidth'],data['imageHeight']
+    if not isinstance(w,(int,float)) or not isinstance(h,(int,float)) or w<=0 or h<=0:
+        raise ValueError('Labelme image dimensions must be positive')
+    annotations = []
+    for shape in data.get('shapes',[]):
+        pts = [[x/w,y/h] for x,y in shape['points']]
+        kind = shape.get('shape_type','polygon')
+        if kind == 'rectangle' and len(pts)==2:
+            geometry = [min(pts[0][0],pts[1][0]),min(pts[0][1],pts[1][1]),max(pts[0][0],pts[1][0]),max(pts[0][1],pts[1][1])]
+            kind = 'box'
+        elif kind == 'polygon': geometry = pts
+        else: raise ValueError(f'Unsupported Labelme shape: {kind}')
+        annotations.append(Annotation(shape['label'],kind,geometry,shape.get('lannotex_id') or shape.get('labelreview_id') or str(uuid.uuid4())))
+    for label,enabled in data.get('flags',{}).items():
+        if enabled is True: annotations.append(Annotation(label,'classification'))
+    negative = bool(data.get('lannotex',{}).get('no_targets',False) or data.get('labelreview',{}).get('no_targets',False))
+    errors = validate_all(annotations,{a.label for a in annotations},negative)
+    if errors: raise ValueError('; '.join(errors))
+    return annotations, negative
+
+
+def yolo_line(a, class_id):
+    if a.kind != 'box': return None
+    x,y,r,b = a.geometry
+    return f'{class_id} {(x+r)/2:.6f} {(y+b)/2:.6f} {r-x:.6f} {b-y:.6f}'
+
+
+def coco_record(image, annotations, labels):
+    output = []
+    w,h = image['width'],image['height']
+    for a in annotations:
+        if a.kind not in ('box','polygon'): continue
+        if a.kind == 'box':
+            x,y,r,b = a.geometry
+            bbox = [x*w,y*h,(r-x)*w,(b-y)*h]
+            segmentation = []; area = bbox[2]*bbox[3]
+        else:
+            xs,ys = [p[0]*w for p in a.geometry],[p[1]*h for p in a.geometry]
+            bbox = [min(xs),min(ys),max(xs)-min(xs),max(ys)-min(ys)]
+            segmentation = [[n for p in a.geometry for n in (p[0]*w,p[1]*h)]]
+            area = polygon_area(a.geometry)*w*h
+        output.append({'id':len(output)+1,'image_id':image['id'],'category_id':labels.index(a.label)+1,
+                       'bbox':bbox,'area':area,'segmentation':segmentation,'iscrowd':0})
+    return {'images':[image],'categories':[{'id':i+1,'name':s} for i,s in enumerate(labels)],'annotations':output}
+
+
+def export_project(root, destination, format_name, cancel, progress):
+    """Stream a consistent DB snapshot; publish the completed directory by rename."""
+    project = Project(root,create=False)
+    project.conn.execute('BEGIN')
+    destination = Path(destination)
+    destination.mkdir(parents=True,exist_ok=True)
+    output = Path(tempfile.mkdtemp(prefix='Lannotex-partial-',dir=destination))
+    summary = {'included':0,'unlabeled':0,'skipped':0,'unsupported_annotations':0,'errors':[], 'format':format_name}
+    try:
+        labels = [r['name'] for r in project.labels()]
+        atomic_text(output/'classes.json',json.dumps(labels,indent=2))
+        # Spool COCO arrays to disk, rather than keeping all annotations in RAM.
+        with (output/'images.jsonl').open('w',encoding='utf-8') as ims, (output/'annotations.jsonl').open('w',encoding='utf-8') as anns, (output/'classification.csv').open('w',encoding='utf-8',newline='') as csvfile:
+            writer = csv.writer(csvfile); writer.writerow(['image_id','image_path','status',*labels])
+            total = project.query(count=True); aid = 0
+            for position,row in enumerate(project.conn.execute('SELECT * FROM images ORDER BY id'),1):
+                if cancel.is_set():
+                    summary['cancelled'] = True; break
+                annotations = project.load_annotations(row['id'])
+                negative = row['status']=='empty'
+                errors = validate_all(annotations,set(labels),negative)
+                if row['width']<=0 or row['height']<=0: errors.append('Invalid image dimensions')
+                if not project.resolve(row['path']).is_file(): errors.append('Missing source image')
+                if project.conn.execute('SELECT 1 FROM drafts WHERE image_id=?',(row['id'],)).fetchone(): errors.append('Uncommitted recovery draft')
+                if errors:
+                    summary['skipped'] += 1
+                    if len(summary['errors'])<100: summary['errors'].append(f"{row['path']}: {'; '.join(errors)}")
+                    continue
+                summary['included'] += 1
+                if row['status']=='new': summary['unlabeled'] += 1
+                name = f"{row['id']:08d}_{Path(row['path']).stem}"
+                source = str(project.resolve(row['path']))
+                image = {'id':row['id'],'file_name':source,'width':row['width'],'height':row['height']}
+                ims.write(json.dumps(image)+'\n')
+                if format_name == 'Labelme JSON':
+                    atomic_text(output/(name+'.json'),json.dumps(labelme_data(source,row['width'],row['height'],annotations,negative),indent=2))
+                elif format_name == 'YOLO boxes':
+                    lines = [yolo_line(a,labels.index(a.label)) for a in annotations if a.kind=='box']
+                    atomic_text(output/(name+'.txt'),'\n'.join(lines)+ ('\n' if lines else ''))
+                    summary['unsupported_annotations'] += sum(a.kind!='box' for a in annotations)
+                elif format_name == 'COCO JSON':
+                    record = coco_record(image,annotations,labels)
+                    for ann in record['annotations']:
+                        aid += 1; ann['id']=aid; anns.write(json.dumps(ann)+'\n')
+                    summary['unsupported_annotations'] += sum(a.kind=='classification' for a in annotations)
+                elif format_name == 'Native JSONL':
+                    anns.write(json.dumps({'image':image,'status':row['status'],'annotations':[a.to_dict() for a in annotations]})+'\n')
+                classes = {a.label for a in annotations if a.kind=='classification'}
+                writer.writerow([row['id'],source,row['status'],*[int(label in classes) for label in labels]])
+                if format_name=='Classification CSV': summary['unsupported_annotations'] += sum(a.kind!='classification' for a in annotations)
+                if position%32==0: progress(round(position/max(1,total)*100),f'Exporting {position:,} / {total:,}')
+        if format_name == 'COCO JSON' and not summary.get('cancelled'):
+            with (output/'coco.json').open('w',encoding='utf-8') as stream:
+                stream.write('{"images":[')
+                for filename,sep in [('images.jsonl','],"annotations":['),('annotations.jsonl','],"categories":')]:
+                    first = True
+                    with (output/filename).open(encoding='utf-8') as lines:
+                        for line in lines:
+                            if not first: stream.write(',')
+                            stream.write(line.strip()); first=False
+                    stream.write(sep)
+                stream.write(json.dumps([{'id':i+1,'name':s} for i,s in enumerate(labels)])+'}')
+        atomic_text(output/'manifest.json',json.dumps({'version':__version__,'format_version':1,'editable_local_export':True,'image_policy':'Referenced, not copied','summary':summary},indent=2))
+        if not summary.get('cancelled'):
+            final = destination/('Lannotex-export-'+uuid.uuid4().hex[:8]); output.rename(final); output=final
+        summary['path'] = str(output)
+        return summary
+    finally:
+        project.conn.rollback(); project.close()
+
+
+def import_annotations(root, source, cancel, progress):
+    """Native JSONL or Labelme; existing labeled images are never overwritten."""
+    from PIL import Image
+    project = Project(root,create=False)
+    source = Path(source)
+    count,errors = 0,[]
+    try:
+        def records():
+            if source.suffix=='.jsonl':
+                with source.open(encoding='utf-8') as stream:
+                    for line in stream:
+                        record=json.loads(line)
+                        yield record['image']['file_name'], record['image']['width'], record['image']['height'], [Annotation.from_dict(a) for a in record['annotations']], record['status']=='empty'
+            else:
+                files = sorted(source.glob('*.json')) if source.is_dir() else [source]
+                for file in files:
+                    data = json.loads(file.read_text(encoding='utf-8'))
+                    if 'shapes' not in data: continue
+                    anns,neg = parse_labelme(data)
+                    yield str((file.parent/data['imagePath']).resolve()),data['imageWidth'],data['imageHeight'],anns,neg
+        for path,w,h,annotations,negative in records():
+            if cancel.is_set(): break
+            try:
+                with Image.open(path) as image:
+                    size=image.size
+                    if image.getexif().get(274,1) in (5,6,7,8): size=size[::-1]
+                    if size != (w,h): raise ValueError('Source dimensions differ from annotation metadata')
+                errors_found=validate_all(annotations,{a.label for a in annotations},negative)
+                if errors_found: raise ValueError('; '.join(errors_found))
+                reference=project.reference(path)
+                existing=project.conn.execute('SELECT * FROM images WHERE path=?',(reference,)).fetchone()
+                if existing and (existing['status']!='new' or project.conn.execute('SELECT 1 FROM drafts WHERE image_id=?',(existing['id'],)).fetchone()):
+                    raise ValueError('Image already has annotations or a draft; skipped')
+                for label in {a.label for a in annotations}:
+                    if label not in {r['name'] for r in project.labels()}: project.add_label(label)
+                ident=project.add_image(path,w,h)
+                project.save_annotations(ident,annotations,negative)
+                count+=1; progress(count,f'Imported annotations for {count} images')
+            except Exception as e:
+                if len(errors)<100: errors.append(f'{path}: {e}')
+        return {'added':count,'errors':errors,'cancelled':cancel.is_set()}
+    finally: project.close()
+
+
+def analyze(root, cancel, progress):
+    project=Project(root,create=False)
+    result={'total':0,'labeled':0,'unlabeled':0,'negative':0,'boxes':0,'polygons':0,'classes':0,'distribution':{},'problems':[]}
+    try:
+        labels={r['name'] for r in project.labels()}
+        result['drafts']=project.conn.execute('SELECT COUNT(*) FROM drafts').fetchone()[0]
+        for row in project.conn.execute('SELECT * FROM images'):
+            if cancel.is_set(): break
+            result['total']+=1
+            result[{'new':'unlabeled','done':'labeled','empty':'negative'}[row['status']]]+=1
+            annotations=project.load_annotations(row['id'])
+            problems=validate_all(annotations,labels,row['status']=='empty')
+            if not project.resolve(row['path']).is_file(): problems.append('Missing source image')
+            for a in annotations:
+                result[{'box':'boxes','polygon':'polygons','classification':'classes'}.get(a.kind,'classes')]+=1
+                result['distribution'][a.label]=result['distribution'].get(a.label,0)+1
+            if problems and len(result['problems'])<200: result['problems'].append(f"{row['path']}: {'; '.join(problems)}")
+        return result
+    finally: project.close()

lannotex/home.py

@@ -0,0 +1,130 @@
+"""Home, recent projects and intentional pipeline setup, independent of editor logic."""
+from pathlib import Path
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (QButtonGroup, QComboBox, QDialog, QDialogButtonBox,
+    QFileDialog, QFrame, QGridLayout, QHBoxLayout, QLabel, QLineEdit, QListWidget,
+    QListWidgetItem, QMessageBox, QPushButton, QScrollArea, QSizePolicy, QTextEdit, QVBoxLayout, QWidget)
+
+PIPELINES = {
+    'classification': ('Classification', 'Assign classes to whole images. No drawing tools.', ['classification']),
+    'detection': ('Object detection', 'Locate objects with editable bounding boxes.', ['box']),
+    'segmentation': ('Segmentation', 'Trace precise regions with polygon vertices.', ['polygon']),
+    'combined': ('Combined pipeline', 'Classes, bounding boxes and polygons together.', ['classification','box','polygon']),
+}
+
+
+def text(value, role='muted'):
+    widget=QLabel(value); widget.setObjectName(role); widget.setWordWrap(True); return widget
+
+
+def pipeline_card(title,description):
+    card=QPushButton(); card.setObjectName('pipeline')
+    card.setSizePolicy(QSizePolicy.Ignored,QSizePolicy.Preferred); card.setMinimumWidth(160)
+    layout=QVBoxLayout(card); layout.setContentsMargins(18,16,18,16); layout.setSpacing(8)
+    for content,role in [(title+'  ↗','cardTitle'),(description,'muted')]:
+        item=text(content,role); item.setAttribute(Qt.WA_TransparentForMouseEvents)
+        layout.addWidget(item)
+    card.setAccessibleName(title); return card
+
+
+class Home(QWidget):
+    create_requested=Signal(str)
+    open_requested=Signal()
+    continue_requested=Signal(str)
+    join_requested=Signal()
+    theme_requested=Signal()
+    preferences_requested=Signal()
+
+    def __init__(self):
+        super().__init__(); self.setObjectName('home')
+        shell=QHBoxLayout(self); shell.setContentsMargins(0,0,0,0); shell.setSpacing(0)
+        rail=QWidget(); rail.setObjectName('rail'); rail.setFixedWidth(220); nav=QVBoxLayout(rail)
+        nav.setContentsMargins(16,28,16,20); nav.setSpacing(8)
+        nav.addWidget(text('◈  Lannotex','brand')); nav.addSpacing(36)
+        for title,signal in [('＋  New project',lambda:self.create_requested.emit('classification')),
+                             ('▤  Open project',self.open_requested.emit),('↗  Join team',self.join_requested.emit)]:
+            b=QPushButton(title); b.setObjectName('nav'); b.clicked.connect(signal); nav.addWidget(b)
+        nav.addStretch(); nav.addWidget(text('YOUR WORKSPACE\nSolo or together. Your data.'))
+        b=QPushButton('◐  Light / dark'); b.setObjectName('nav'); b.clicked.connect(self.theme_requested); nav.addWidget(b)
+        b=QPushButton('Settings && shortcuts'); b.setObjectName('nav'); b.clicked.connect(self.preferences_requested); nav.addWidget(b)
+        shell.addWidget(rail)
+        scroll=QScrollArea(); scroll.setWidgetResizable(True); scroll.setFrameShape(QFrame.NoFrame)
+        page=QWidget(); layout=QVBoxLayout(page); layout.setContentsMargins(52,38,52,28); layout.setSpacing(18)
+        layout.addStretch(1); layout.addWidget(text('A little more clarity.\nA lot better data.','hero'))
+        layout.addWidget(text('Choose your workflow. Pick up where you left off.','subtitle')); layout.addSpacing(12)
+        grid=QGridLayout(); grid.setSpacing(12)
+        for i,(key,(title,description,_)) in enumerate(PIPELINES.items()):
+            card=pipeline_card(title,description)
+            card.setToolTip(description); card.clicked.connect(lambda checked=False,k=key:self.create_requested.emit(k))
+            grid.addWidget(card,i//2,i%2)
+        layout.addLayout(grid); layout.addSpacing(14)
+        row=QHBoxLayout(); row.addWidget(text('Continue working','cardTitle')); row.addStretch()
+        self.continue_button=QPushButton('Continue  →'); self.continue_button.setObjectName('primary')
+        self.continue_button.clicked.connect(self.resume); row.addWidget(self.continue_button)
+        b=QPushButton('Open another…'); b.clicked.connect(self.open_requested); row.addWidget(b); layout.addLayout(row)
+        self.recents=QListWidget(); self.recents.setMinimumHeight(130); self.recents.setMaximumHeight(260)
+        self.recents.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff); self.recents.setTextElideMode(Qt.ElideMiddle)
+        self.recents.itemDoubleClicked.connect(lambda item:self.continue_requested.emit(item.data(Qt.UserRole)))
+        layout.addWidget(self.recents)
+        self.empty=text('No recent projects yet. Create your first project above.'); layout.addWidget(self.empty)
+        layout.addStretch(1)
+        layout.addWidget(text('Solo projects work offline. Team projects connect only to the host you choose.'))
+        scroll.setWidget(page); shell.addWidget(scroll,1)
+
+    def refresh(self, recent):
+        self.recents.clear()
+        for path in recent:
+            exists=(Path(path)/'project.sqlite3').is_file()
+            item=QListWidgetItem(f"{Path(path).name}{'' if exists else ' · unavailable'}\n{path}")
+            item.setData(Qt.UserRole,path); self.recents.addItem(item)
+        if self.recents.count(): self.recents.setCurrentRow(0)
+        self.empty.setVisible(not self.recents.count()); self.continue_button.setEnabled(bool(self.recents.count()))
+
+    def resume(self):
+        item=self.recents.currentItem()
+        if item: self.continue_requested.emit(item.data(Qt.UserRole))
+
+
+class CreateProjectDialog(QDialog):
+    def __init__(self, pipeline='classification', parent=None):
+        super().__init__(parent); self.setWindowTitle('Create a project'); self.resize(680,650)
+        layout=QVBoxLayout(self); layout.setContentsMargins(28,24,28,24); layout.setSpacing(12)
+        layout.addWidget(text('Make room for your next dataset.','cardTitle'))
+        self.name=QLineEdit(); self.name.setPlaceholderText('Project name'); layout.addWidget(self.name)
+        location=QHBoxLayout(); self.location=QLineEdit(); self.location.setPlaceholderText('Parent folder for the project')
+        location.addWidget(self.location); browse=QPushButton('Browse…'); browse.clicked.connect(self.browse); location.addWidget(browse); layout.addLayout(location)
+        self.pipelines=QButtonGroup(self); self.pipelines.setExclusive(True); grid=QGridLayout()
+        self.buttons={}
+        for i,(key,(title,description,_)) in enumerate(PIPELINES.items()):
+            b=pipeline_card(title,description); b.setCheckable(True)
+            self.pipelines.addButton(b); self.buttons[key]=b; grid.addWidget(b,i//2,i%2)
+        self.buttons[pipeline].setChecked(True); layout.addLayout(grid)
+        self.mode=QComboBox(); self.mode.addItem('Solo · just me','solo'); self.mode.addItem('Team · simultaneous reviewers on different computers','team')
+        layout.addWidget(text('Who is working on this project?')); layout.addWidget(self.mode)
+        self.classes=QTextEdit(); self.classes.setPlaceholderText('Classes / object labels, one per line\nYou can also add them later.'); self.classes.setMaximumHeight(100); layout.addWidget(self.classes)
+        layout.addWidget(text('Team mode uses this computer as the project host. You control who can connect.'))
+        buttons=QDialogButtonBox(QDialogButtonBox.Cancel); create=buttons.addButton('Create project',QDialogButtonBox.AcceptRole)
+        create.setObjectName('primary'); buttons.accepted.connect(self.validate); buttons.rejected.connect(self.reject); layout.addWidget(buttons)
+
+    def browse(self):
+        path=QFileDialog.getExistingDirectory(self,'Choose parent folder')
+        if path: self.location.setText(path)
+
+    def validate(self):
+        name=self.name.text().strip()
+        if not name or name in ('.','..') or any(c in name for c in '<>:"/\\|?*') or name.endswith(('.', ' ')):
+            QMessageBox.warning(self,'Project name','Enter a valid folder name.'); return
+        if not Path(self.location.text()).is_dir() or not self.location.text().strip():
+            QMessageBox.warning(self,'Project location','Choose an existing parent folder.'); return
+        if self.folder.exists() and any(self.folder.iterdir()):
+            QMessageBox.warning(self,'Folder already exists','Choose a new name; this folder is not empty.'); return
+        labels=[s.strip() for s in self.classes.toPlainText().splitlines() if s.strip()]
+        if len(labels)!=len(set(labels)) or any(len(s)>120 for s in labels):
+            QMessageBox.warning(self,'Labels','Use unique labels of 1–120 characters.'); return
+        self.accept()
+
+    @property
+    def folder(self): return Path(self.location.text())/self.name.text().strip()
+
+    @property
+    def pipeline(self): return next(key for key,b in self.buttons.items() if b.isChecked())

lannotex/models.py

@@ -0,0 +1,51 @@
+from collections import OrderedDict
+from pathlib import Path
+from PySide6.QtCore import QAbstractListModel, QModelIndex, Qt, QSize
+from PySide6.QtGui import QColor
+
+
+class ImageListModel(QAbstractListModel):
+    """Virtual list: at most eight pages of 128 metadata records in memory."""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.project = None
+        self.search = ''
+        self.status = 'all'
+        self.total = 0
+        self.pages = OrderedDict()
+
+    def refresh(self, project=None, search=None, status=None):
+        self.beginResetModel()
+        if project is not None: self.project = project
+        if search is not None: self.search = search
+        if status is not None: self.status = status
+        self.pages.clear()
+        self.total = self.project.query(self.search,self.status,count=True) if self.project else 0
+        self.endResetModel()
+
+    def rowCount(self, parent=QModelIndex()): return 0 if parent.isValid() else self.total
+
+    def record(self, row):
+        if not 0 <= row < self.total: return None
+        page = row//128
+        if page not in self.pages:
+            self.pages[page] = self.project.query(self.search,self.status,offset=page*128)
+            while len(self.pages)>8: self.pages.popitem(last=False)
+        self.pages.move_to_end(page)
+        return self.pages[page][row%128]
+
+    def data(self, index, role=Qt.DisplayRole):
+        if not index.isValid(): return None
+        if role == Qt.SizeHintRole: return QSize(200,58)
+        row = self.record(index.row())
+        if row is None: return None
+        if role == Qt.DisplayRole:
+            state = {'new':'Unlabeled', 'done':'Labeled', 'empty':'No targets'}.get(row['status'],row['status'])
+            return f"{Path(row['path']).name}\n{state}  ·  {row['width']} × {row['height']}"
+        if role == Qt.ToolTipRole: return row['path']
+        if role == Qt.ForegroundRole and row['status'] != 'new': return QColor('#888888')
+        if role == Qt.UserRole: return dict(row)
+
+    def invalidate(self):
+        self.pages.clear()
+        if self.total: self.dataChanged.emit(self.index(0),self.index(self.total-1))

lannotex/storage.py

@@ -0,0 +1,241 @@
+"""Versioned SQLite projects. Every worker owns its connection."""
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+import sqlite3
+import tempfile
+from .domain import Annotation, validate_all
+
+# Migration 1 matches the shipped prototype; changes are appended.
+MIGRATIONS = [
+    ["CREATE TABLE IF NOT EXISTS images(id INTEGER PRIMARY KEY, path TEXT UNIQUE NOT NULL, width INTEGER, height INTEGER, status TEXT NOT NULL DEFAULT 'new')",
+     "CREATE TABLE IF NOT EXISTS labels(name TEXT PRIMARY KEY, color TEXT NOT NULL DEFAULT '#38bdf8')",
+     "CREATE TABLE IF NOT EXISTS annotations(id TEXT PRIMARY KEY, image_id INTEGER NOT NULL, data TEXT NOT NULL, FOREIGN KEY(image_id) REFERENCES images(id))",
+     "CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY, value TEXT NOT NULL)"],
+    ["CREATE INDEX IF NOT EXISTS annotations_image ON annotations(image_id)",
+     "CREATE INDEX IF NOT EXISTS images_status ON images(status)",
+     "CREATE TABLE IF NOT EXISTS drafts(image_id INTEGER PRIMARY KEY REFERENCES images(id), data TEXT NOT NULL, negative INTEGER NOT NULL DEFAULT 0)"],
+    ["CREATE TABLE revisions(image_id INTEGER PRIMARY KEY REFERENCES images(id), revision INTEGER NOT NULL DEFAULT 0)",
+     "CREATE TABLE team_members(id TEXT PRIMARY KEY, name TEXT NOT NULL, token_hash TEXT UNIQUE NOT NULL, active INTEGER NOT NULL DEFAULT 1)",
+     "CREATE TABLE team_audit(id INTEGER PRIMARY KEY AUTOINCREMENT, image_id INTEGER NOT NULL, member TEXT NOT NULL, revision INTEGER NOT NULL, saved_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP)",
+     "CREATE TABLE team_changes(seq INTEGER PRIMARY KEY AUTOINCREMENT, image_id INTEGER NOT NULL)",
+     "CREATE TABLE team_links(image_id INTEGER PRIMARY KEY REFERENCES images(id), remote_revision INTEGER NOT NULL DEFAULT 0, dirty INTEGER NOT NULL DEFAULT 0, conflict INTEGER NOT NULL DEFAULT 0)",
+     "INSERT INTO revisions(image_id) SELECT id FROM images",
+     "INSERT INTO team_changes(image_id) SELECT id FROM images",
+     "CREATE TRIGGER image_added AFTER INSERT ON images BEGIN INSERT INTO revisions(image_id) VALUES(NEW.id); INSERT INTO team_changes(image_id) VALUES(NEW.id); END"],
+    ["ALTER TABLE team_audit ADD COLUMN data TEXT NOT NULL DEFAULT '[]'",
+     "ALTER TABLE team_audit ADD COLUMN negative INTEGER NOT NULL DEFAULT 0"],
+    ["ALTER TABLE drafts ADD COLUMN base_revision INTEGER"]
+]
+
+
+def atomic_text(path, text):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temp = tempfile.mkstemp(prefix='.lannotex-', dir=path.parent)
+    try:
+        with os.fdopen(fd, 'w', encoding='utf-8', newline='') as stream:
+            stream.write(text)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temp, path)
+    finally:
+        if os.path.exists(temp): os.unlink(temp)
+
+
+class Project:
+    def __init__(self, root, create=True):
+        self.root = Path(root).resolve()
+        self.db_path = self.root / 'project.sqlite3'
+        if not create and not self.db_path.is_file(): raise FileNotFoundError('No project.sqlite3 in this folder')
+        self.root.mkdir(parents=True, exist_ok=True)
+        self.conn = sqlite3.connect(self.db_path, timeout=2)
+        self.conn.row_factory = sqlite3.Row
+        try:
+            self.conn.execute('PRAGMA foreign_keys=ON')
+            self.conn.execute('PRAGMA journal_mode=WAL')
+            self.conn.execute('PRAGMA synchronous=FULL')
+            self._migrate()
+        except Exception:
+            self.conn.close()
+            raise
+
+    def _migrate(self):
+        with self.conn:
+            self.conn.execute('BEGIN IMMEDIATE')
+            self.conn.execute('CREATE TABLE IF NOT EXISTS migrations(version INTEGER PRIMARY KEY)')
+            done = {r[0] for r in self.conn.execute('SELECT version FROM migrations')}
+            if done and max(done) > len(MIGRATIONS): raise ValueError('Project requires a newer Lannotex version')
+            for version, statements in enumerate(MIGRATIONS, 1):
+                if version not in done:
+                    for sql in statements: self.conn.execute(sql)
+                    self.conn.execute('INSERT INTO migrations VALUES(?)', (version,))
+
+    def close(self): self.conn.close()
+    def labels(self): return self.conn.execute('SELECT name,color FROM labels ORDER BY name').fetchall()
+
+    def add_label(self, name, color='#37b8a5'):
+        name = name.strip()
+        if not name or len(name) > 120: raise ValueError('Enter a label of 1–120 characters')
+        with self.conn: self.conn.execute('INSERT INTO labels VALUES(?,?)', (name, color))
+
+    def rename_label(self, old, new):
+        new = new.strip()
+        if not new or len(new) > 120: raise ValueError('Enter a label of 1–120 characters')
+        with self.conn:
+            self.conn.execute('UPDATE labels SET name=? WHERE name=?', (new, old))
+            affected=set()
+            for row in self.conn.execute('SELECT id,image_id,data FROM annotations').fetchall():
+                data = json.loads(row['data'])
+                if data['label'] == old:
+                    data['label'] = new
+                    self.conn.execute('UPDATE annotations SET data=? WHERE id=?', (json.dumps(data), row['id']))
+                    affected.add(row['image_id'])
+            for row in self.conn.execute('SELECT image_id,data FROM drafts').fetchall():
+                data = json.loads(row['data'])
+                for a in data:
+                    if a['label'] == old: a['label'] = new
+                self.conn.execute('UPDATE drafts SET data=? WHERE image_id=?', (json.dumps(data), row['image_id']))
+            for ident in affected:
+                self.conn.execute('UPDATE revisions SET revision=revision+1 WHERE image_id=?',(ident,))
+                self.conn.execute('INSERT INTO team_changes(image_id) VALUES(?)',(ident,))
+
+    def remove_label(self, name):
+        for row in self.conn.execute('SELECT data FROM annotations UNION ALL SELECT data FROM drafts'):
+            data = json.loads(row[0])
+            if any(a['label'] == name for a in (data if isinstance(data, list) else [data])):
+                raise ValueError('This label is in use. Rename it, or relabel its annotations first.')
+        with self.conn: self.conn.execute('DELETE FROM labels WHERE name=?', (name,))
+
+    def reference(self, path):
+        path = Path(path).resolve()
+        try: return os.path.relpath(path, self.root)
+        except ValueError: return str(path)
+
+    def resolve(self, reference): return (self.root / reference).resolve()
+
+    def add_image(self, path, width=0, height=0):
+        path = self.reference(path)
+        with self.conn: self.conn.execute('INSERT OR IGNORE INTO images(path,width,height) VALUES(?,?,?)', (path, width, height))
+        return self.conn.execute('SELECT id FROM images WHERE path=?', (path,)).fetchone()[0]
+
+    def add_batch(self, records):
+        with self.conn:
+            inserted = self.conn.executemany('INSERT OR IGNORE INTO images(path,width,height) VALUES(?,?,?)', records)
+            return inserted.rowcount
+
+    def images(self): return self.conn.execute('SELECT * FROM images ORDER BY path').fetchall()
+    def image(self, ident): return self.conn.execute('SELECT * FROM images WHERE id=?', (ident,)).fetchone()
+
+    def query(self, search='', status='all', offset=0, limit=128, count=False):
+        where, args = [], []
+        if search:
+            where.append("path LIKE ? ESCAPE '\\'")
+            args.append('%'+search.replace('\\','\\\\').replace('%','\\%').replace('_','\\_')+'%')
+        if status != 'all': where.append('status=?'); args.append(status)
+        sql = 'SELECT '+('COUNT(*)' if count else '*')+' FROM images'
+        if where: sql += ' WHERE '+' AND '.join(where)
+        if not count: sql += ' ORDER BY path LIMIT ? OFFSET ?'; args.extend([limit, offset])
+        result = self.conn.execute(sql, args)
+        return result.fetchone()[0] if count else result.fetchall()
+
+    def load_annotations(self, image_id):
+        return [Annotation.from_dict(json.loads(r[0])) for r in self.conn.execute('SELECT data FROM annotations WHERE image_id=? ORDER BY rowid', (image_id,))]
+
+    def load_state(self, image_id):
+        draft = self.conn.execute('SELECT * FROM drafts WHERE image_id=?', (image_id,)).fetchone()
+        if draft: return [Annotation.from_dict(a) for a in json.loads(draft['data'])], bool(draft['negative']), True
+        return self.load_annotations(image_id), self.image(image_id)['status'] == 'empty', False
+
+    def load_document(self, image_id):
+        with self.conn:
+            self.conn.execute('BEGIN')
+            annotations,negative,recovered=self.load_state(image_id)
+            revision=self.conn.execute('SELECT revision FROM revisions WHERE image_id=?',(image_id,)).fetchone()[0]
+            draft=self.conn.execute('SELECT base_revision FROM drafts WHERE image_id=?',(image_id,)).fetchone()
+            if draft and draft[0] is not None: revision=draft[0]
+            return annotations,negative,recovered,revision
+
+    def save_draft(self, image_id, annotations, negative=False, base_revision=None):
+        with self.conn:
+            if base_revision is None:
+                base_revision=self.conn.execute('SELECT revision FROM revisions WHERE image_id=?',(image_id,)).fetchone()[0]
+            self.conn.execute('INSERT INTO drafts(image_id,data,negative,base_revision) VALUES(?,?,?,?) '
+                              'ON CONFLICT(image_id) DO UPDATE SET data=excluded.data,negative=excluded.negative',
+                              (image_id, json.dumps([a.to_dict() for a in annotations]), int(negative),base_revision))
+
+    def save_annotations(self, image_id, annotations, negative=False, actor='Local owner', expected_revision=None, clear_draft=True):
+        errors = validate_all(annotations, {r['name'] for r in self.labels()}, negative)
+        if errors: raise ValueError('; '.join(errors))
+        payload = [(a.id, image_id, json.dumps(a.to_dict(), separators=(',', ':'))) for a in annotations]
+        with self.conn:
+            self.conn.execute('BEGIN IMMEDIATE')
+            current=self.conn.execute('SELECT revision FROM revisions WHERE image_id=?',(image_id,)).fetchone()
+            if current is None: raise ValueError('Image does not exist')
+            if expected_revision is not None and current[0]!=expected_revision: raise ConflictError('Another reviewer saved this image. Reload or resolve the conflict before saving.')
+            self.conn.execute('DELETE FROM annotations WHERE image_id=?', (image_id,))
+            self.conn.executemany('INSERT INTO annotations VALUES(?,?,?)', payload)
+            self.conn.execute('UPDATE images SET status=? WHERE id=?', ('empty' if negative else 'done' if annotations else 'new', image_id))
+            if clear_draft: self.conn.execute('DELETE FROM drafts WHERE image_id=?', (image_id,))
+            self.conn.execute('UPDATE revisions SET revision=revision+1 WHERE image_id=?',(image_id,))
+            self.conn.execute('INSERT INTO team_changes(image_id) VALUES(?)',(image_id,))
+            self.conn.execute('INSERT INTO team_audit(image_id,member,revision,data,negative) VALUES(?,?,?,?,?)',
+                              (image_id,actor,current[0]+1,json.dumps([a.to_dict() for a in annotations]),int(negative)))
+            if self.setting('team_remote'):
+                self.conn.execute('UPDATE team_links SET dirty=1 WHERE image_id=?',(image_id,))
+
+    def setting(self, key, default=None):
+        row = self.conn.execute('SELECT value FROM settings WHERE key=?', (key,)).fetchone()
+        return json.loads(row[0]) if row else default
+
+    def set_setting(self, key, value):
+        with self.conn: self.conn.execute('INSERT OR REPLACE INTO settings VALUES(?,?)', (key, json.dumps(value)))
+
+    def relink(self, image_id, path, width, height):
+        old = self.image(image_id)
+        if (old['width'], old['height']) != (width, height): raise ValueError('Replacement dimensions differ; annotations would be misaligned')
+        with self.conn: self.conn.execute('UPDATE images SET path=? WHERE id=?', (self.reference(path), image_id))
+
+    def backup(self, target):
+        target = Path(target).resolve()
+        if target == self.db_path: raise ValueError('Choose a different backup path')
+        target.parent.mkdir(parents=True, exist_ok=True)
+        fd, temp = tempfile.mkstemp(dir=target.parent, suffix='.sqlite3'); os.close(fd)
+        try:
+            out = sqlite3.connect(temp)
+            try:
+                self.conn.backup(out)
+                out.execute('INSERT OR REPLACE INTO settings VALUES(?,?)',('backup_source_root',json.dumps(str(self.root))))
+                out.commit()
+            finally: out.close()
+            os.replace(temp, target)
+        finally:
+            if os.path.exists(temp): os.unlink(temp)
+
+    @classmethod
+    def restore(cls, source, folder):
+        destination = Path(folder) / 'project.sqlite3'
+        if destination.exists(): raise ValueError('Restore requires a folder without an existing project')
+        source = Path(source).resolve()
+        check = sqlite3.connect(source.as_uri()+'?mode=ro', uri=True)
+        try:
+            if check.execute('PRAGMA integrity_check').fetchone()[0] != 'ok': raise ValueError('Backup is damaged')
+            check.execute('SELECT version FROM migrations').fetchall()
+            Path(folder).mkdir(parents=True, exist_ok=True)
+            out = sqlite3.connect(destination)
+            try: check.backup(out)
+            finally: out.close()
+        finally: check.close()
+        restored=cls(folder,create=False)
+        old_root=restored.setting('backup_source_root')
+        if old_root:
+            with restored.conn:
+                for row in restored.images():
+                    old_path=Path(old_root)/row['path']
+                    restored.conn.execute('UPDATE images SET path=? WHERE id=?',(restored.reference(old_path),row['id']))
+        return restored
+
+
+class ConflictError(ValueError):
+    """A stale edit must never replace a newer shared revision."""