compair-core 0.4.12__py3-none-any.whl

compair_core/compair/models.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+import binascii
+import hashlib
+import os
+import secrets
+from datetime import datetime, timezone
+from math import sqrt
+from typing import Sequence
+from uuid import uuid4
+
+try:  # Optional: only required when using pgvector backend
+    from pgvector.sqlalchemy import Vector
+except ImportError:  # pragma: no cover - optional dependency in core
+    Vector = None  # type: ignore[assignment]
+
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Identity,
+    Integer,
+    JSON,
+    String,
+    Table,
+    Text,
+)
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,
+    MappedAsDataclass,
+    mapped_column,
+    relationship,
+)
+
+_EDITION = os.getenv("COMPAIR_EDITION", "core").lower()
+_DEFAULT_DIM = 1536 if _EDITION == "cloud" else 384
+_DIM_ENV = (
+    os.getenv("COMPAIR_EMBEDDING_DIM")
+    or os.getenv("COMPAIR_EMBEDDING_DIMENSION")
+    or os.getenv("COMPAIR_LOCAL_EMBED_DIM")
+    or str(_DEFAULT_DIM)
+)
+
+try:
+    EMBEDDING_DIMENSION = int(_DIM_ENV)
+except ValueError:  # pragma: no cover - invalid configuration
+    EMBEDDING_DIMENSION = _DEFAULT_DIM
+
+
+def _detect_vector_backend() -> str:
+    explicit = os.getenv("COMPAIR_VECTOR_BACKEND")
+    if explicit:
+        return explicit.lower()
+
+    db = os.getenv("DB")
+    db_user = os.getenv("DB_USER")
+    db_passw = os.getenv("DB_PASSW")
+    db_url = os.getenv("DB_URL")
+    database_url = os.getenv("DATABASE_URL", "")
+
+    if all([db, db_user, db_passw, db_url]):
+        return "pgvector"
+    if database_url.lower().startswith(("postgres://", "postgresql://")):
+        return "pgvector"
+    return "json"
+
+
+VECTOR_BACKEND = _detect_vector_backend()
+
+
+def _embedding_column():
+    if VECTOR_BACKEND == "pgvector":
+        if Vector is None:
+            raise RuntimeError(
+                "pgvector is required when COMPAIR_VECTOR_BACKEND is set to 'pgvector'."
+            )
+        return mapped_column(
+            Vector(EMBEDDING_DIMENSION),
+            nullable=True,
+            default=None,
+        )
+    # Store embeddings as JSON arrays (works across SQLite/Postgres without pgvector)
+    return mapped_column(JSON, nullable=True, default=None)
+
+
+def cosine_similarity(vec1: Sequence[float] | None, vec2: Sequence[float] | None) -> float | None:
+    if not vec1 or not vec2:
+        return None
+    if len(vec1) != len(vec2):
+        return None
+    dot = sum(a * b for a, b in zip(vec1, vec2))
+    norm1 = sqrt(sum(a * a for a in vec1))
+    norm2 = sqrt(sum(b * b for b in vec2))
+    if norm1 == 0 or norm2 == 0:
+        return None
+    return dot / (norm1 * norm2)
+
+
+class Base(DeclarativeBase, MappedAsDataclass):
+    pass
+
+
+class BaseObject(Base):
+    __abstract__ = True
+
+
+class User(Base):
+    __tablename__ = "user"
+    
+
+    user_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    username: Mapped[str] = mapped_column(String(128))
+    name: Mapped[str] = mapped_column(String(256))
+    role: Mapped[str | None] = mapped_column(String(128), nullable=True)
+    profile_image: Mapped[str | None] = mapped_column(String, nullable=True)
+    verification_token: Mapped[str | None] = mapped_column(String, nullable=True)
+    reset_token: Mapped[str | None] = mapped_column(String, nullable=True)
+    token_expiration: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    datetime_registered: Mapped[datetime]
+    status_change_date: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    password_hash: Mapped[str]
+    password_salt: Mapped[str]
+
+    status: Mapped[str] = mapped_column(String(16), default="inactive")
+    include_own_documents_in_feedback: Mapped[bool] = mapped_column(Boolean, default=False)
+    default_publish: Mapped[bool] = mapped_column(Boolean, default=True)
+    preferred_feedback_length: Mapped[str] = mapped_column(String(16), default="Brief")
+    hide_affiliations: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    groups = relationship("Group", secondary="user_to_group", back_populates="users")
+    documents = relationship(
+        "Document",
+        back_populates="user",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+    notes = relationship(
+        "Note",
+        back_populates="author",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+
+    activities = relationship(
+        "Activity",
+        back_populates="user",
+        cascade="all, delete-orphan"
+    )
+
+    def __init__(
+        self,
+        username: str,
+        name: str,
+        datetime_registered: datetime,
+        verification_token: str | None,
+        token_expiration: datetime | None,
+    ):
+        super().__init__()
+        self.username = username
+        self.name = name
+        self.datetime_registered = datetime_registered
+        self.verification_token = verification_token
+        self.token_expiration = token_expiration
+        self.status = "inactive"
+        self.status_change_date = datetime.now(timezone.utc)
+
+    def set_password(self, password: str) -> str:
+        salt = os.urandom(64)
+        self.password_salt = binascii.hexlify(salt).decode("utf-8")
+        hash_bytes = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, 100000)
+        self.password_hash = binascii.hexlify(hash_bytes).decode("utf-8")
+        return self.password_hash
+
+    def check_password(self, password: str) -> bool:
+        if not self.password_salt or not self.password_hash:
+            return False
+        salt = binascii.unhexlify(self.password_salt.encode("utf-8"))
+        hash_bytes = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, 100000)
+        hash_hex = binascii.hexlify(hash_bytes).decode("utf-8")
+        return secrets.compare_digest(self.password_hash, hash_hex)
+
+
+class Session(Base):
+    __tablename__ = "session"
+    
+
+    id: Mapped[str] = mapped_column(String(128), primary_key=True, init=True)
+    user_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"), index=True)
+    datetime_created: Mapped[datetime]
+    datetime_valid_until: Mapped[datetime]
+
+
+class Group(BaseObject):
+    __tablename__ = "group"
+    
+
+    group_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    name: Mapped[str] = mapped_column(String(256))
+    datetime_created: Mapped[datetime]
+    group_image: Mapped[str | None] = mapped_column(String, nullable=True)
+    category: Mapped[str] = mapped_column(String(256), default="Other")
+    description: Mapped[str] = mapped_column(Text, default="")
+    visibility: Mapped[str] = mapped_column(String(32), default="public")
+
+    users = relationship("User", secondary="user_to_group", back_populates="groups")
+    admins = relationship("Administrator", secondary="admin_to_group", back_populates="groups")
+    documents = relationship("Document", secondary="document_to_group", back_populates="groups")
+    notes = relationship("Note", secondary="note_to_group", back_populates="groups")
+
+    activities = relationship(
+        "Activity",
+        back_populates="group",
+        cascade="all, delete-orphan"
+    )
+
+    __mapper_args__ = {"primary_key": [group_id]}
+
+    @property
+    def document_count(self) -> int:
+        return len(self.documents)
+
+    @property
+    def user_count(self) -> int:
+        return len(self.users)
+
+    @property
+    def first_three_user_profile_images(self) -> list[str | None]:
+        return [user.profile_image for user in self.users[:3]]
+
+
+class Administrator(Base):
+    __tablename__ = "administrator"
+    
+
+    admin_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"), index=True)
+
+    user = relationship("User")
+    groups = relationship("Group", secondary="admin_to_group", back_populates="admins")
+
+
+class JoinRequest(Base):
+    __tablename__ = "join_request"
+    
+
+    request_id: Mapped[int] = mapped_column(Identity(), primary_key=True, autoincrement=True, init=False)
+    user_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"))
+    group_id: Mapped[str] = mapped_column(ForeignKey("group.group_id", ondelete="CASCADE"))
+    datetime_requested: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc), init=False)
+
+    user = relationship("User")
+    group = relationship("Group")
+
+
+class GroupInvitation(Base):
+    __tablename__ = "group_invitation"
+    
+
+    invitation_id: Mapped[int] = mapped_column(Integer, Identity(), primary_key=True, autoincrement=True, init=False)
+    group_id: Mapped[str] = mapped_column(ForeignKey("group.group_id", ondelete="CASCADE"))
+    inviter_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"))
+    token: Mapped[str] = mapped_column(String(64), unique=True, nullable=False)
+    email: Mapped[str | None] = mapped_column(String(256), nullable=True)
+    datetime_expiration: Mapped[datetime]
+    datetime_created: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc), init=False)
+    status: Mapped[str] = mapped_column(String(32), default="pending")
+
+    group = relationship("Group")
+    inviter = relationship("User")
+
+
+class Document(BaseObject):
+    __tablename__ = "document"
+    
+
+    document_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"), index=True)
+    author_id: Mapped[str]
+    title: Mapped[str]
+    content: Mapped[str] = mapped_column(Text)
+    doc_type: Mapped[str]
+    datetime_created: Mapped[datetime]
+    datetime_modified: Mapped[datetime]
+    embedding: Mapped[list[float] | None] = _embedding_column()
+    file_key: Mapped[str | None] = mapped_column(String, nullable=True, default=None)
+    image_key: Mapped[str | None] = mapped_column(String, nullable=True, default=None)
+    is_published: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    user = relationship("User", back_populates="documents")
+    groups = relationship("Group", secondary="document_to_group", back_populates="documents")
+    chunks = relationship(
+        "Chunk",
+        back_populates="document",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+    references = relationship(
+        "Reference",
+        back_populates="document",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+    notes = relationship(
+        "Note",
+        back_populates="document",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+
+
+class Note(Base):
+    __tablename__ = "note"
+    
+
+    note_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    document_id: Mapped[str] = mapped_column(ForeignKey("document.document_id", ondelete="CASCADE"), index=True)
+    author_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"), index=True)
+    group_id: Mapped[str | None] = mapped_column(ForeignKey("group.group_id", ondelete="CASCADE"), index=True, nullable=True)
+    content: Mapped[str] = mapped_column(Text)
+    embedding: Mapped[list[float] | None] = _embedding_column()
+    datetime_created: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc))
+
+    document = relationship("Document", back_populates="notes")
+    author = relationship("User", back_populates="notes")
+    groups = relationship("Group", back_populates="notes")
+    chunks = relationship(
+        "Chunk",
+        back_populates="note",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+    references = relationship(
+        "Reference",
+        back_populates="note",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+
+
+class Chunk(Base):
+    __tablename__ = "chunk"
+    
+
+    chunk_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    hash: Mapped[str] = mapped_column(String(32))
+    content: Mapped[str] = mapped_column(Text)
+    document_id: Mapped[str | None] = mapped_column(ForeignKey("document.document_id", ondelete="CASCADE"), index=True, nullable=True)
+    note_id: Mapped[str | None] = mapped_column(ForeignKey("note.note_id", ondelete="CASCADE"), index=True, nullable=True)
+    chunk_type: Mapped[str] = mapped_column(String(16), default="document")
+    embedding: Mapped[list[float] | None] = _embedding_column()
+
+    document = relationship("Document", back_populates="chunks")
+    note = relationship("Note", back_populates="chunks")
+    references = relationship(
+        "Reference",
+        back_populates="chunk",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+    feedbacks = relationship(
+        "Feedback",
+        back_populates="chunk",
+        cascade="all, delete",
+        passive_deletes=True,
+    )
+
+
+class Reference(Base):
+    __tablename__ = "reference"
+    
+
+    reference_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    source_chunk_id: Mapped[str] = mapped_column(ForeignKey("chunk.chunk_id", ondelete="CASCADE"), index=True)
+    reference_document_id: Mapped[str | None] = mapped_column(ForeignKey("document.document_id", ondelete="CASCADE"), index=True, nullable=True)
+    reference_note_id: Mapped[str | None] = mapped_column(ForeignKey("note.note_id", ondelete="CASCADE"), index=True, nullable=True)
+    reference_type: Mapped[str] = mapped_column(String(16), default="document")
+
+    chunk = relationship("Chunk", back_populates="references")
+    document = relationship("Document", back_populates="references")
+    note = relationship("Note", back_populates="references")
+
+
+class Feedback(Base):
+    __tablename__ = "feedback"
+
+
+    feedback_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    source_chunk_id: Mapped[str] = mapped_column(ForeignKey("chunk.chunk_id", ondelete="CASCADE"), index=True)
+    feedback: Mapped[str] = mapped_column(Text)
+    model: Mapped[str] = mapped_column(Text)
+    timestamp: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.now(timezone.utc))
+    user_feedback: Mapped[str | None] = mapped_column(String(16), nullable=True, default=None)
+    is_hidden: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    chunk = relationship("Chunk", back_populates="feedbacks")
+
+
+class Activity(Base):
+    __tablename__ = "activity"
+
+    activity_id: Mapped[int] = mapped_column(Identity(), primary_key=True, init=False, autoincrement=True)
+    user_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"), nullable=False)
+    group_id: Mapped[str] = mapped_column(ForeignKey("group.group_id", ondelete="CASCADE"), nullable=False)
+    action: Mapped[str] = mapped_column(String(32))
+    object_id: Mapped[str] = mapped_column(String(36))
+    object_name: Mapped[str] = mapped_column(Text)
+    object_type: Mapped[str] = mapped_column(String(32))
+    timestamp: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc))
+
+    user = relationship("User", back_populates="activities", lazy="joined")
+    group = relationship("Group", back_populates="activities")
+
+
+user_to_group_table = Table(
+    "user_to_group",
+    Base.metadata,
+    Column("user_id", ForeignKey("user.user_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+
+admin_to_group_table = Table(
+    "admin_to_group",
+    Base.metadata,
+    Column("admin_id", ForeignKey("administrator.admin_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+
+document_to_group_table = Table(
+    "document_to_group",
+    Base.metadata,
+    Column("document_id", ForeignKey("document.document_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+note_to_group_table = Table(
+    "note_to_group",
+    Base.metadata,
+    Column("note_id", ForeignKey("note.note_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+
+try:
+    from compair_cloud.models import extend_models  # type: ignore
+except (ImportError, ModuleNotFoundError):
+    extend_models = None
+
+if extend_models:
+    extend_models(Base, globals())

compair_core/compair/schema.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class GroupForm:
+    name: str
+    user_id: Optional[str] = None
+    group_id: Optional[str] = None
+    datetime_created: Optional[datetime] = None
+    category: Optional[str] = None
+    description: Optional[str] = None
+    visibility: Optional[str] = None
+
+
+class Group(BaseModel):
+    name: str
+    user_id: Optional[str] = None
+    group_id: Optional[str] = None
+    datetime_created: Optional[datetime] = None
+    group_image: Optional[str] = None
+    category: Optional[str] = None
+    description: Optional[str] = None
+    visibility: Optional[str] = None
+
+    model_config = {"from_attributes": True}
+
+
+class User(BaseModel):
+    user_id: str
+    username: str
+    name: str
+    datetime_registered: datetime
+    status: str
+    groups: Optional[list[Group]] = None
+    profile_image: Optional[str] = None
+    role: Optional[str] = None
+
+    model_config = {"from_attributes": True}
+
+
+class UpdateUserRequest(BaseModel):
+    user_id: str
+    name: Optional[str] = None
+    role: Optional[str] = None
+    group_ids: Optional[list[str]] = None
+
+
+class Session(BaseModel):
+    id: str
+    user_id: str
+    datetime_created: datetime
+    datetime_valid_until: datetime
+
+
+class Document(BaseModel):
+    document_id: str
+    user_id: str
+    author_id: str
+    groups: list[Group]
+    user: User
+    title: str
+    content: str
+    doc_type: str
+    datetime_created: datetime
+    datetime_modified: datetime
+    is_published: bool
+    file_key: Optional[str] = None
+    image_key: Optional[str] = None
+
+    model_config = {"from_attributes": True}
+
+
+class Chunk(BaseModel):
+    chunk_id: str
+    hash: str
+    document_id: str
+    content: str
+
+
+class Reference(BaseModel):
+    reference_id: str
+    source_chunk_id: str
+    reference_document_id: str
+    document: Document
+    document_author: str
+
+
+class Feedback(BaseModel):
+    feedback_id: str
+    source_chunk_id: str
+    feedback: str
+    user_feedback: str | None = None
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class SignUpRequest(BaseModel):
+    username: str
+    name: str
+    password: str
+    groups: list[Group] | None
+    referral_code: str | None = None
+
+
+class ForgotPasswordRequest(BaseModel):
+    email: str
+
+
+class ResetPasswordRequest(BaseModel):
+    token: str
+    new_password: str
+
+
+class Note(BaseModel):
+    note_id: str
+    document_id: str
+    author_id: str
+    group_id: str | None = None
+    content: str
+    datetime_created: datetime
+    author: User | None = None
+    group: Group | None = None
+
+
+class InviteToGroupRequest(BaseModel):
+    admin_id: str
+    group_id: str
+    email: str
+
+
+class InviteMemberRequest(BaseModel):
+    admin_id: str
+    group_id: str
+    username: str
+
+
+class RemoveMemberRequest(BaseModel):
+    group_id: str
+    user_id: str

compair_core/compair/tasks.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import logging
+from typing import Mapping
+
+logger = logging.getLogger(__name__)
+
+try:
+    from compair_cloud.tasks import (  # type: ignore
+        process_document_task,
+        process_text_task,
+        check_trial_expirations,
+        expire_group_invitations,
+        send_trial_warnings,
+        send_feature_announcement_task,
+        send_deactivate_request_email,
+        send_help_request_email,
+        send_daily_usage_report,
+    )
+except (ImportError, ModuleNotFoundError) as exc:
+    logger.warning(
+        "Failed to import compair_cloud.tasks; using core task implementations. (%s: %s)",
+        exc.__class__.__name__,
+        exc,
+        exc_info=exc,
+    )
+    from sqlalchemy.orm import joinedload
+
+    def _lazy_components():
+        from . import Session as SessionMaker
+        from .embeddings import Embedder
+        from .feedback import Reviewer
+        from .logger import log_event
+        from .main import process_document
+        from .models import Document, User
+
+        return SessionMaker, Embedder, Reviewer, log_event, process_document, Document, User
+
+    logger = logging.getLogger(__name__)
+
+    def process_document_task(
+        user_id: str,
+        doc_id: str,
+        doc_text: str,
+        generate_feedback: bool = True,
+    ) -> Mapping[str, list[str]]:
+        SessionMaker, Embedder, Reviewer, log_event, process_document, Document, User = _lazy_components()
+        with SessionMaker() as session:
+            user = session.query(User).filter(User.user_id == user_id).first()
+            if not user:
+                logger.warning("User not found for document processing", extra={"user_id": user_id})
+                return {"chunk_task_ids": []}
+
+            doc = (
+                session.query(Document)
+                .options(joinedload(Document.groups))
+                .filter(Document.document_id == doc_id)
+                .first()
+            )
+            if not doc:
+                logger.warning("Document not found for processing", extra={"document_id": doc_id})
+                return {"chunk_task_ids": []}
+
+            doc.content = doc_text
+            session.add(doc)
+
+            embedder = Embedder()
+            reviewer = Reviewer()
+
+            process_document(user, session, embedder, reviewer, doc, generate_feedback=generate_feedback)
+
+            log_event(
+                "core_document_processed",
+                user_id=user_id,
+                document_id=doc_id,
+                feedback_requested=generate_feedback,
+            )
+
+            return {"chunk_task_ids": []}
+
+    def process_text_task(*args, **kwargs):  # pragma: no cover
+        raise RuntimeError("process_text_task is only available in the Compair Cloud edition.")
+
+    def check_trial_expirations():  # pragma: no cover
+        raise RuntimeError("check_trial_expirations is only available in the Compair Cloud edition.")
+
+    def expire_group_invitations():  # pragma: no cover
+        raise RuntimeError("expire_group_invitations is only available in the Compair Cloud edition.")
+
+    def send_trial_warnings():  # pragma: no cover
+        raise RuntimeError("send_trial_warnings is only available in the Compair Cloud edition.")
+
+    def send_feature_announcement_task():  # pragma: no cover
+        raise RuntimeError("send_feature_announcement_task is only available in the Compair Cloud edition.")
+
+    def send_deactivate_request_email(*args, **kwargs):  # pragma: no cover
+        raise RuntimeError("send_deactivate_request_email is only available in the Compair Cloud edition.")
+
+    def send_help_request_email(*args, **kwargs):  # pragma: no cover
+        raise RuntimeError("send_help_request_email is only available in the Compair Cloud edition.")
+
+    def send_daily_usage_report():  # pragma: no cover
+        raise RuntimeError("send_daily_usage_report is only available in the Compair Cloud edition.")
+
+    def process_file_with_ocr_task(*args, **kwargs):  # pragma: no cover
+        raise RuntimeError("OCR processing is only available in the Compair Cloud edition.")