apsimo 1.3.0__py3-none-any.whl

apsimo/world_model/expectation_resolvers.py

@@ -0,0 +1,177 @@
+"""World-model expectation resolvers (Mind M3a x world model).
+
+The expectation engine keeps its store generic and lets subsystems register
+how a class of predictions gets checked against reality. This module supplies
+the two world-model classes:
+
+- ``world-relationship:`` -- "this relationship is still active at the
+  horizon". ``detail`` carries ``source_id``/``target_id`` and optionally
+  ``relationship_type``.
+- ``world-property:`` -- "this entity property still holds this value at the
+  horizon". ``detail`` carries ``entity_id``/``key``/``value``.
+
+Resolvers return True (hit), False (miss), or None when the world model
+cannot see the subject -- the prediction then stays pending and eventually
+goes ``unresolved``, which is excluded from calibration (never a fabricated
+miss). The world store is fetched lazily at resolve time so boot order does
+not matter, and the async store API is bridged the same way the briefing
+aggregators do it (``asyncio.run`` off-loop, a worker thread on-loop).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+RELATIONSHIP_PREFIX = "world-relationship:"
+PROPERTY_PREFIX = "world-property:"
+
+# Historical edge-survival bookkeeping is self-consistency, not an
+# independently observed causal outcome. Retain old rows/functions for audit.
+CAUSAL_PREFIX = "world-causal:"
+
+
+def _world_store() -> Any:
+    try:
+        from apsimo.api.routers.host import _world_store as ws
+        return ws
+    except Exception:
+        return None
+
+
+def _run_async(coro: Any) -> Any:
+    """Run a store coroutine from the engine's synchronous resolver path."""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    # Already on an event loop (the autonomy phase) — blocking on this loop
+    # would deadlock, so complete the coroutine on its own loop in a worker.
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+        return ex.submit(asyncio.run, coro).result(timeout=10.0)
+
+
+def _norm(v: Any) -> str:
+    return str(v if v is not None else "").strip().lower()
+
+
+def resolve_relationship_still_active(prediction: Any) -> Optional[bool]:
+    """Hit when at least one matching relationship is still active.
+
+    Causal-typed predictions are NOT resolved here (query-only guard,
+    H2.5): a causal edge must never be scored true/false through the
+    generic relationship machinery — its falsifiability path is the causal
+    subsystem's own. Returning None leaves the prediction unresolved,
+    which calibration excludes (never a fabricated hit or miss).
+    """
+    store = _world_store()
+    detail = getattr(prediction, "detail", None) or {}
+    source_id = detail.get("source_id")
+    target_id = detail.get("target_id")
+    if store is None or not source_id or not target_id:
+        return None
+    try:
+        from apsimo.world_model.causal_policy import is_causal
+        if is_causal(detail.get("relationship_type") or ""):
+            return None
+    except Exception:
+        return None
+    rels = _run_async(store.query_relationships(
+        source_id=source_id, target_id=target_id,
+        relationship_type=detail.get("relationship_type") or None,
+        active_only=False, min_confidence=0.0, limit=50))
+    if not rels:
+        # never observed -> the world model cannot score this prediction
+        return None
+    return any(getattr(r, "is_active", False) for r in rels)
+
+
+def resolve_property_unchanged(prediction: Any) -> Optional[bool]:
+    """Hit when the entity property still equals the predicted value."""
+    store = _world_store()
+    detail = getattr(prediction, "detail", None) or {}
+    entity_id = detail.get("entity_id")
+    key = detail.get("key")
+    if store is None or not entity_id or not key or "value" not in detail:
+        return None
+    entity = _run_async(store.get_entity(entity_id, min_confidence=0.0))
+    if entity is None:
+        return None
+    props = getattr(entity, "properties", None) or {}
+    if key not in props:
+        # the property is no longer tracked at all — that is a visibility
+        # loss, not evidence the value changed; leave it unresolvable
+        return None
+    return _norm(props.get(key)) == _norm(detail.get("value"))
+
+
+def resolve_causal_edge(prediction: Any) -> Optional[bool]:
+    """Historical self-consistency only; never predictive calibration.
+
+    HIT: the edge still exists, is active, holds at least the confidence it
+    had when the prediction was made, and no opposing edge (H2.3 polarity)
+    exists on the same ordered pair.
+    MISS: the edge decayed below its creation confidence, was deleted or
+    deactivated, or acquired an active opposing edge.
+    None: the world store cannot be seen at all (never a fabricated miss).
+    """
+    store = _world_store()
+    detail = getattr(prediction, "detail", None) or {}
+    edge_id = detail.get("edge_id")
+    source_id = detail.get("source_id")
+    target_id = detail.get("target_id")
+    rel_type = str(detail.get("relationship_type") or "").upper()
+    try:
+        conf_floor = float(detail.get("confidence_at_creation"))
+    except (TypeError, ValueError):
+        return None
+    if store is None or not edge_id or not source_id or not target_id\
+            or not rel_type:
+        return None
+    try:
+        rels = _run_async(store.query_relationships(
+            source_id=source_id, target_id=target_id,
+            relationship_type=rel_type, min_confidence=0.0, limit=50))
+    except Exception:
+        return None  # store unreachable -> unseen, not a miss
+    edge = next((r for r in rels or [] if r.id == edge_id), None)
+    if edge is None:
+        # fall back to same pair + type (the claim, if not the row)
+        edge = (rels or [None])[0]
+    if edge is None:
+        return False  # deleted — the claim did not survive
+    if getattr(edge, "valid_to", None) is not None:
+        return False  # deactivated
+    if float(getattr(edge, "confidence", 0.0) or 0.0) < conf_floor:
+        return False  # decayed below its creation confidence
+    # Opposing edge on the same ordered pair (H2.3 polarity sets)?
+    try:
+        from apsimo.world_model.causal_maintenance import (
+            NEGATIVE_CAUSAL, POSITIVE_CAUSAL,
+        )
+        opposing = (NEGATIVE_CAUSAL if rel_type in POSITIVE_CAUSAL
+                    else POSITIVE_CAUSAL if rel_type in NEGATIVE_CAUSAL
+                    else frozenset())
+        for opp_type in sorted(opposing):
+            opp = _run_async(store.query_relationships(
+                source_id=source_id, target_id=target_id,
+                relationship_type=opp_type, min_confidence=0.0, limit=10))
+            if any(getattr(o, "valid_to", None) is None for o in opp or []):
+                return False  # opposed
+    except Exception:
+        return None  # cannot verify the no-opposition clause -> unseen
+    return True
+
+
+def register_world_resolvers(engine: Any) -> None:
+    """Attach the world-model resolvers to an ExpectationEngine."""
+    if engine is None:
+        return
+    engine.register_resolver(RELATIONSHIP_PREFIX,
+                             resolve_relationship_still_active)
+    engine.register_resolver(PROPERTY_PREFIX, resolve_property_unchanged)
+    # Causal edge survival is deliberately not registered as outcome truth.

apsimo/world_model/extraction/__init__.py

@@ -0,0 +1,7 @@
+"""World model entity extraction from multiple document formats."""
+
+from apsimo.world_model.extraction.base import FormatExtractor
+from apsimo.world_model.extraction.detector import FormatDetector
+from apsimo.world_model.extraction.pipeline import ExtractionPipeline
+
+__all__ = ["FormatExtractor", "FormatDetector", "ExtractionPipeline"]

apsimo/world_model/extraction/base.py

@@ -0,0 +1,62 @@
+"""Base class for format extractors."""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ExtractedEntity:
+    """An entity extracted from a document."""
+
+    def __init__(
+        self,
+        name: str,
+        entity_type: str,
+        attributes: Optional[Dict[str, Any]] = None,
+        source_offset: Optional[int] = None,
+        confidence: float = 1.0,
+    ):
+        self.name = name
+        self.entity_type = entity_type
+        self.attributes = attributes or {}
+        self.source_offset = source_offset
+        self.confidence = confidence
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "type": self.entity_type,
+            "attributes": self.attributes,
+            "confidence": self.confidence,
+        }
+
+
+class FormatExtractor(ABC):
+    """Base class for document format extractors.
+
+    Each extractor handles one or more MIME types and can:
+    1. Extract raw text from the document
+    2. Extract structured entities directly (without LLM)
+    """
+
+    @abstractmethod
+    def supported_formats(self) -> List[str]:
+        """Return list of MIME types this extractor handles."""
+        ...
+
+    @abstractmethod
+    async def extract_text(self, content: bytes, metadata: Dict[str, Any]) -> str:
+        """Extract raw text from content. Returns empty string if extraction fails."""
+        ...
+
+    async def extract_entities(self, content: bytes, metadata: Dict[str, Any]) -> List[ExtractedEntity]:
+        """Extract structured entities directly from content (no LLM).
+
+        Default implementation returns empty list. Override for formats
+        that have structured data (JSON, CSV).
+        """
+        return []

apsimo/world_model/extraction/conversation_extractor.py

@@ -0,0 +1,262 @@
+"""Lightweight post-message entity extractor.
+
+Uses rule-based NER and regex patterns. Zero LLM calls.
+MUST complete within 50ms for single-message inputs.
+"""
+
+import re
+import time
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from ..confidence import CONFIDENCE_BY_SOURCE, apply_extraction_adjustments
+
+
+# ── Regex patterns for structured entity signals ──────────────────────────────
+
+_EMAIL_RE = re.compile(
+    r"\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b"
+)
+_DOMAIN_RE = re.compile(
+    r"\b(?:https?://)?([A-Za-z0-9\-]+\.(?:com|org|net|io|ai|co|app|dev|tech))\b",
+    re.IGNORECASE,
+)
+_TICKER_RE = re.compile(r"\b([A-Z]{2,5})\b(?=\s*(?:stock|shares|ticker|NYSE|NASDAQ|$))")
+_PHONE_RE = re.compile(
+    r"\+?\d[\d\s\-\(\)]{7,}\d"
+)
+_URL_RE = re.compile(
+    r"https?://[^\s<>\"']+", re.IGNORECASE
+)
+
+# Capitalized-word person/org heuristic (1–4 consecutive title-cased tokens).
+# Single-word matches are filtered against _NAME_STOPWORDS before use.
+_CAPITALIZED_NAME_RE = re.compile(
+    r"\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,3})\b"
+)
+
+# Common English words that appear capitalized but are not proper names.
+# Filtered out when the regex produces a single-word match.
+_NAME_STOPWORDS = frozenset({
+    "The", "A", "An", "This", "That", "These", "Those",
+    "He", "She", "It", "We", "They", "You", "I",
+    "His", "Her", "Its", "Our", "Their", "My", "Your",
+    "Is", "Are", "Was", "Were", "Be", "Been", "Being",
+    "Has", "Have", "Had", "Do", "Does", "Did",
+    "Will", "Would", "Could", "Should", "May", "Might", "Must",
+    "In", "At", "To", "By", "For", "Of", "On", "Off",
+    "With", "From", "About", "Into", "Through", "During",
+    "And", "Or", "But", "If", "As", "So", "Yet", "Nor",
+    "Not", "No", "Yes", "Ok", "Please", "Thanks", "Thank",
+    "Here", "There", "Now", "Then", "When", "Where", "How", "Why",
+    "What", "Which", "Who", "Whose",
+    "Also", "Just", "Very", "More", "Most", "Some", "Any",
+    "All", "Both", "Each", "Few", "Many", "Much", "Other",
+    "After", "Before", "Over", "Under", "Above", "Below",
+    "Between", "Among", "Against", "Along", "Around",
+    "Can", "Cannot", "Well", "Even", "Still", "Already",
+    "Never", "Always", "Often", "Again", "Since", "Once",
+    "Hi", "Hey", "Hello", "Okay", "Sure", "Yeah",
+})
+
+# Common org suffixes. The name is 1-4 consecutive Title-case tokens immediately
+# before the suffix -- NOT a greedy run across lowercase words (which used to
+# swallow whole sentences, e.g. "I met Alice at Acme Corp" -> one "company").
+_ORG_SUFFIX_RE = re.compile(
+    r"\b((?:[A-Z][A-Za-z&.\-]*\s+){0,3}[A-Z][A-Za-z&.\-]*"
+    r"\s+(?:Inc\.?|Corp\.?|LLC|Ltd\.?|Co\.?|Group|Foundation|Institute|University|"
+    r"School|Hospital|Agency|Association|Society|Department))\b"
+)
+
+# Location indicators
+_LOCATION_INDICATORS = frozenset({
+    "in", "at", "from", "to", "near", "visit", "located", "based", "headquartered",
+    "office", "city", "country", "region", "state", "province",
+})
+
+
+@dataclass
+class ExtractionCandidate:
+    """A candidate entity or relationship found in text."""
+    text: str                     # the extracted text span
+    entity_type: str              # tentative entity type
+    start_char: int
+    end_char: int
+    confidence: float
+    context_window: str           # surrounding text for disambiguation
+    linked_entity_id: Optional[str] = None  # if resolved to existing entity
+
+
+@dataclass
+class ExtractionResult:
+    entities: List[ExtractionCandidate] = field(default_factory=list)
+    relationships: List[dict] = field(default_factory=list)
+    extraction_ms: float = 0.0
+    source_id: str = ""           # message ID that was processed
+
+
+class ConversationExtractor:
+    """Lightweight post-message entity extractor.
+
+    Uses rule-based NER and regex patterns. Zero LLM calls.
+    MUST complete within 50ms for single-message inputs.
+    """
+
+    def __init__(
+        self,
+        min_message_length: int = 20,
+        existing_entities: Optional[List[str]] = None,
+    ) -> None:
+        self._min_length = min_message_length
+        self._known_names: List[str] = list(existing_entities or [])
+
+    def _context(self, text: str, start: int, end: int, window: int = 40) -> str:
+        return text[max(0, start - window): min(len(text), end + window)]
+
+    async def extract(
+        self,
+        message_text: str,
+        source_id: str,
+        existing_entities: Optional[List[str]] = None,
+    ) -> ExtractionResult:
+        """Extract entity candidates from a single message.
+
+        Args:
+            message_text: Raw message content.
+            source_id: The message ID for provenance tracking.
+            existing_entities: List of known entity names for fast linking.
+
+        Returns:
+            ExtractionResult with candidates and elapsed time.
+        """
+        t0 = time.monotonic()
+        result = ExtractionResult(source_id=source_id)
+
+        if len(message_text) < self._min_length:
+            result.extraction_ms = (time.monotonic() - t0) * 1000
+            return result
+
+        known = set(existing_entities or []) | set(self._known_names)
+        seen_spans: List[tuple] = []  # (start, end) to avoid duplicates
+
+        def _overlaps(s: int, e: int) -> bool:
+            for a, b in seen_spans:
+                if s < b and e > a:
+                    return True
+            return False
+
+        # ── Emails → person (high confidence) ────────────────────────────────
+        for m in _EMAIL_RE.finditer(message_text):
+            if _overlaps(m.start(), m.end()):
+                continue
+            adj = [0.15]  # email pattern bonus
+            if m.group() in known:
+                adj.append(0.20)
+            conf = apply_extraction_adjustments(
+                CONFIDENCE_BY_SOURCE["conversation_ner"], adj
+            )
+            result.entities.append(ExtractionCandidate(
+                text=m.group(),
+                entity_type="person",
+                start_char=m.start(),
+                end_char=m.end(),
+                confidence=conf,
+                context_window=self._context(message_text, m.start(), m.end()),
+            ))
+            seen_spans.append((m.start(), m.end()))
+
+        # ── URLs → product/company ─────────────────────────────────────────
+        for m in _URL_RE.finditer(message_text):
+            if _overlaps(m.start(), m.end()):
+                continue
+            conf = apply_extraction_adjustments(
+                CONFIDENCE_BY_SOURCE["conversation_ner"], [0.05]
+            )
+            result.entities.append(ExtractionCandidate(
+                text=m.group(),
+                entity_type="product",
+                start_char=m.start(),
+                end_char=m.end(),
+                confidence=conf,
+                context_window=self._context(message_text, m.start(), m.end()),
+            ))
+            seen_spans.append((m.start(), m.end()))
+
+        # ── Org suffix → company ──────────────────────────────────────────
+        for m in _ORG_SUFFIX_RE.finditer(message_text):
+            full = m.group().strip()
+            if _overlaps(m.start(), m.end()):
+                continue
+            adj = []
+            if full in known:
+                adj.append(0.20)
+            conf = apply_extraction_adjustments(
+                CONFIDENCE_BY_SOURCE["conversation_ner"], adj
+            )
+            result.entities.append(ExtractionCandidate(
+                text=full,
+                entity_type="company",
+                start_char=m.start(),
+                end_char=m.end(),
+                confidence=conf,
+                context_window=self._context(message_text, m.start(), m.end()),
+            ))
+            seen_spans.append((m.start(), m.end()))
+
+        # ── Capitalized names → person ────────────────────────────────────
+        for m in _CAPITALIZED_NAME_RE.finditer(message_text):
+            name = m.group().strip()
+            if _overlaps(m.start(), m.end()):
+                continue
+            # Skip single-word all-caps (likely acronym/ticker)
+            if name.isupper():
+                continue
+            is_single_word = " " not in name
+            # Skip single-word matches that are common English stopwords
+            if is_single_word and name in _NAME_STOPWORDS:
+                continue
+            adj = []
+            if name in known:
+                adj.append(0.20)
+            # Single-word proper names get lower confidence than multi-word names
+            if is_single_word:
+                adj.append(-0.10)
+            conf = apply_extraction_adjustments(
+                CONFIDENCE_BY_SOURCE["conversation_ner"], adj
+            )
+            # Heuristic: check if preceded by location indicator
+            prefix = message_text[max(0, m.start() - 30):m.start()].lower()
+            etype = "person"
+            for indicator in _LOCATION_INDICATORS:
+                if indicator in prefix.split():
+                    etype = "location"
+                    break
+            result.entities.append(ExtractionCandidate(
+                text=name,
+                entity_type=etype,
+                start_char=m.start(),
+                end_char=m.end(),
+                confidence=conf,
+                context_window=self._context(message_text, m.start(), m.end()),
+            ))
+            seen_spans.append((m.start(), m.end()))
+
+        # ── Domain names → company ────────────────────────────────────────
+        for m in _DOMAIN_RE.finditer(message_text):
+            if _overlaps(m.start(), m.end()):
+                continue
+            conf = apply_extraction_adjustments(
+                CONFIDENCE_BY_SOURCE["conversation_ner"], [0.05]
+            )
+            result.entities.append(ExtractionCandidate(
+                text=m.group(1),
+                entity_type="company",
+                start_char=m.start(),
+                end_char=m.end(),
+                confidence=conf,
+                context_window=self._context(message_text, m.start(), m.end()),
+            ))
+            seen_spans.append((m.start(), m.end()))
+
+        result.extraction_ms = (time.monotonic() - t0) * 1000
+        return result

apsimo/world_model/extraction/detector.py

@@ -0,0 +1,74 @@
+"""Format detection for document content."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Common extension to MIME type mapping
+EXTENSION_MAP = {
+    ".pdf": "application/pdf",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".json": "application/json",
+    ".csv": "text/csv",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".xml": "application/xml",
+    ".yaml": "application/x-yaml",
+    ".yml": "application/x-yaml",
+}
+
+# Magic byte signatures
+MAGIC_SIGNATURES = {
+    b"%PDF": "application/pdf",
+    b"<!DOCTYPE": "text/html",
+    b"<html": "text/html",
+    b"<?xml": "application/xml",
+}
+
+
+class FormatDetector:
+    """Detect document format from content, filename, or explicit MIME type."""
+
+    def detect(
+        self,
+        content: bytes,
+        filename: str = "",
+        mime_type: str = "",
+    ) -> str:
+        """Detect content format.
+
+        Priority: explicit mime_type > filename extension > magic bytes > fallback.
+        """
+        # 1. Explicit MIME type wins
+        if mime_type:
+            return mime_type
+
+        # 2. Filename extension
+        if filename:
+            ext = Path(filename).suffix.lower()
+            if ext in EXTENSION_MAP:
+                return EXTENSION_MAP[ext]
+
+        # 3. Magic bytes
+        if content:
+            for sig, fmt in MAGIC_SIGNATURES.items():
+                if content[:len(sig)].startswith(sig):
+                    return fmt
+
+            # JSON detection
+            stripped = content[:512].strip()
+            if stripped and stripped[0:1] in (b"{", b"["):
+                return "application/json"
+
+            # CSV detection (simple heuristic)
+            first_line = content[:512].split(b"\n")[0]
+            if b"," in first_line and first_line.count(b",") >= 2:
+                return "text/csv"
+
+        # 4. Fallback
+        return "text/plain"

apsimo/world_model/extraction/document_extractor.py

@@ -0,0 +1,78 @@
+"""Background document entity extractor.
+
+Invoked via task queue. MAY use heavier NER models.
+Processes structured documents and returns typed entity candidates.
+"""
+
+import base64
+from enum import Enum
+from typing import Optional
+
+from .conversation_extractor import ExtractionResult, ConversationExtractor
+
+
+class DocumentType(str, Enum):
+    PDF = "pdf"
+    HTML = "html"
+    EMAIL_BODY = "email_body"
+    PLAIN_TEXT = "plain_text"
+    CALENDAR_ICS = "calendar_ics"
+
+
+class DocumentExtractor:
+    """Background document entity extractor.
+
+    Invoked via task queue. MAY use heavier NER models.
+    Processes structured documents and returns typed entity candidates.
+    """
+
+    def __init__(self) -> None:
+        self._conv_extractor = ConversationExtractor(min_message_length=0)
+
+    async def extract_from_document(
+        self,
+        content: bytes,
+        document_type: DocumentType,
+        source_reference: str,
+    ) -> ExtractionResult:
+        """Extract entities from a document.
+
+        Args:
+            content: Raw document bytes.
+            document_type: The type of document being processed.
+            source_reference: Email ID, URL, or file path for provenance.
+
+        Returns:
+            ExtractionResult with full entity and relationship candidates.
+        """
+        text = self._decode_content(content, document_type)
+        return await self._conv_extractor.extract(
+            message_text=text,
+            source_id=source_reference,
+        )
+
+    def _decode_content(self, content: bytes, document_type: DocumentType) -> str:
+        """Decode raw bytes to text based on document type."""
+        if document_type == DocumentType.HTML:
+            return self._strip_html(content.decode("utf-8", errors="replace"))
+        elif document_type == DocumentType.CALENDAR_ICS:
+            return self._parse_ics(content.decode("utf-8", errors="replace"))
+        else:
+            return content.decode("utf-8", errors="replace")
+
+    def _strip_html(self, html: str) -> str:
+        """Minimal HTML tag stripper."""
+        import re
+        text = re.sub(r"<[^>]+>", " ", html)
+        text = re.sub(r"&[a-z]+;", " ", text)
+        return re.sub(r"\s+", " ", text).strip()
+
+    def _parse_ics(self, ics: str) -> str:
+        """Extract displayable text from iCal content."""
+        lines = []
+        for line in ics.splitlines():
+            for prefix in ("SUMMARY:", "DESCRIPTION:", "LOCATION:", "ORGANIZER:"):
+                if line.startswith(prefix):
+                    lines.append(line[len(prefix):].strip())
+                    break
+        return " ".join(lines)

apsimo/world_model/extraction/formats/__init__.py

@@ -0,0 +1,24 @@
+"""Extraction formats package."""
+
+from apsimo.world_model.extraction.formats.text import TextExtractor
+from apsimo.world_model.extraction.formats.json_fmt import JSONExtractor
+from apsimo.world_model.extraction.formats.csv_fmt import CSVExtractor
+
+# Optional extractors — load if dependencies are available
+try:
+    from apsimo.world_model.extraction.formats.pdf import PDFExtractor
+except ImportError:
+    PDFExtractor = None
+
+try:
+    from apsimo.world_model.extraction.formats.html_fmt import HTMLExtractor
+except ImportError:
+    HTMLExtractor = None
+
+__all__ = [
+    "TextExtractor",
+    "JSONExtractor",
+    "CSVExtractor",
+    "PDFExtractor",
+    "HTMLExtractor",
+]