compair-core 0.4.12__py3-none-any.whl

compair_core/compair/utils.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import secrets
+from datetime import datetime, timedelta, timezone
+
+from sqlalchemy.orm import Session
+
+from .models import Activity
+
+
+def chunk_text(text: str) -> list[str]:
+    chunks = text.split("\n\n")
+    chunks = [c.strip() for c in chunks]
+    return [c for c in chunks if c]
+
+
+def generate_verification_token() -> tuple[str, datetime]:
+    token = secrets.token_urlsafe(32)
+    expiration = datetime.now(timezone.utc) + timedelta(hours=24)
+    return token, expiration
+
+
+def log_activity(
+    session: Session,
+    user_id: str,
+    group_id: str,
+    action: str,
+    object_id: str,
+    object_name: str,
+    object_type: str,
+) -> None:
+    activity = Activity(
+        user_id=user_id,
+        group_id=group_id,
+        action=action,
+        object_id=object_id,
+        object_name=object_name,
+        object_type=object_type,
+        timestamp=datetime.now(timezone.utc),
+    )
+    session.add(activity)
+    session.commit()

compair_core/compair_email/email.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+try:  # Cloud build ships the premium mailer
+    from compair_cloud.compair_email.email import *  # type: ignore
+except (ImportError, ModuleNotFoundError):
+    from .email_core import *  # type: ignore

compair_core/compair_email/email_core.py

@@ -0,0 +1,15 @@
+import os
+
+from redmail import EmailSender
+
+EMAIL_HOST = f"{os.environ.get('EMAIL_HOST')}"
+EMAIL_USER = f"{os.environ.get('EMAIL_USER')}"
+EMAIL_PW = f"{os.environ.get('EMAIL_PW')}"
+
+emailer = EmailSender(
+    host=EMAIL_HOST,  
+    port=587, 
+    username=EMAIL_USER,
+    password=EMAIL_PW,
+    use_starttls=True 
+)

compair_core/compair_email/templates.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+try:
+    from compair_cloud.compair_email.templates import *  # type: ignore
+except (ImportError, ModuleNotFoundError):
+    from .templates_core import *  # type: ignore

compair_core/compair_email/templates_core.py

@@ -0,0 +1,32 @@
+"""Minimal email templates for the core edition."""
+
+ACCOUNT_VERIFY_TEMPLATE = """
+<p>Hi {{user_name}},</p>
+<p>Please verify your Compair account by clicking the link below:</p>
+<p><a href="{{verify_link}}">Verify my account</a></p>
+<p>Thanks!</p>
+""".strip()
+
+PASSWORD_RESET_TEMPLATE = """
+<p>We received a request to reset your password.</p>
+<p>Your password reset code is: <strong>{{reset_code}}</strong></p>
+""".strip()
+
+GROUP_INVITATION_TEMPLATE = """
+<p>{{inviter_name}} invited you to join the group {{group_name}}.</p>
+<p><a href="{{invitation_link}}">Accept invitation</a></p>
+""".strip()
+
+GROUP_JOIN_TEMPLATE = """
+<p>{{user_name}} has joined your group.</p>
+""".strip()
+
+INDIVIDUAL_INVITATION_TEMPLATE = """
+<p>{{inviter_name}} invited you to Compair.</p>
+<p><a href="{{referral_link}}">Join now</a></p>
+""".strip()
+
+REFERRAL_CREDIT_TEMPLATE = """
+<p>Hi {{user_name}},</p>
+<p>Great news! You now have {{referral_credits}} referral credits.</p>
+""".strip()

compair_core/db.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from sqlalchemy import Engine, create_engine
+from sqlalchemy.orm import sessionmaker
+
+
+def _build_engine() -> Engine:
+    """Create the SQLAlchemy engine using the same precedence as the core package."""
+    explicit_url = (
+        os.getenv("COMPAIR_DATABASE_URL")
+        or os.getenv("COMPAIR_DB_URL")
+        or os.getenv("DATABASE_URL")
+    )
+    if explicit_url:
+        if explicit_url.startswith("sqlite:"):
+            return create_engine(explicit_url, connect_args={"check_same_thread": False})
+        return create_engine(explicit_url)
+
+    # Backwards compatibility with legacy Postgres env variables
+    db = os.getenv("DB")
+    db_user = os.getenv("DB_USER")
+    db_passw = os.getenv("DB_PASSW")
+    db_host = os.getenv("DB_URL")
+
+    if all([db, db_user, db_passw, db_host]):
+        return create_engine(
+            f"postgresql+psycopg2://{db_user}:{db_passw}@{db_host}/{db}",
+            pool_size=10,
+            max_overflow=0,
+        )
+
+    # Local default: place an SQLite database inside COMPAIR_DB_DIR
+    db_dir = (
+        os.getenv("COMPAIR_DB_DIR")
+        or os.getenv("COMPAIR_SQLITE_DIR")
+        or os.path.join(Path.home(), ".compair-core", "data")
+    )
+    db_name = os.getenv("COMPAIR_DB_NAME") or os.getenv("COMPAIR_SQLITE_NAME") or "compair.db"
+
+    db_path = Path(db_dir).expanduser()
+    try:
+        db_path.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        fallback_dir = Path(os.getcwd()) / "compair_data"
+        fallback_dir.mkdir(parents=True, exist_ok=True)
+        db_path = fallback_dir
+
+    sqlite_path = db_path / db_name
+    return create_engine(
+        f"sqlite:///{sqlite_path}",
+        connect_args={"check_same_thread": False},
+    )
+
+
+engine = _build_engine()
+
+# Keep behavior identical to previous `Session = sessionmaker(engine)`
+SessionLocal = sessionmaker(engine)
+Session = SessionLocal
+
+__all__ = ["engine", "SessionLocal", "Session"]

compair_core/server/app.py

@@ -0,0 +1,97 @@
+"""FastAPI app factory supporting Core and Cloud editions."""
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+from .deps import (
+    get_analytics,
+    get_billing,
+    get_mailer,
+    get_ocr,
+    get_settings_dependency,
+    get_storage,
+)
+from .providers.local_storage import LocalStorage
+from .routers.capabilities import router as capabilities_router
+from .settings import Settings, get_settings
+
+
+def _normalize_edition(value: str) -> str:
+    return (value or "core").lower()
+
+
+def create_app(settings: Settings | None = None) -> FastAPI:
+    """Instantiate the FastAPI application with edition-specific wiring."""
+
+    resolved_settings = settings or get_settings()
+    edition = _normalize_edition(resolved_settings.edition)
+
+    app = FastAPI(title="Compair API", version=resolved_settings.version)
+
+    from ..api import core_router, router as legacy_router
+
+    if edition == "cloud":
+        app.include_router(legacy_router)
+    else:
+        if resolved_settings.include_legacy_routes:
+            app.include_router(legacy_router)
+        else:
+            app.include_router(core_router)
+    app.include_router(capabilities_router)
+
+    # Share the resolved settings with request handlers
+    app.dependency_overrides[get_settings_dependency] = lambda: resolved_settings
+
+    if edition == "cloud":
+        try:
+            from compair_cloud.analytics.ga4 import GA4Analytics
+            from compair_cloud.billing.stripe_provider import StripeBilling
+            from compair_cloud.mailer.transactional import TransactionalMailer
+            from compair_cloud.ocr.claude_ocr import ClaudeOCR
+            from compair_cloud.storage.r2_storage import R2Storage
+        except ImportError as exc:  # pragma: no cover - only triggered in misconfigured builds
+            raise RuntimeError(
+                "Cloud edition requires the private 'compair_cloud' package to be installed."
+            ) from exc
+
+        storage_provider = R2Storage(
+            bucket=resolved_settings.r2_bucket,
+            cdn_base=resolved_settings.r2_cdn_base,
+            access_key=resolved_settings.r2_access_key,
+            secret_key=resolved_settings.r2_secret_key,
+            endpoint_url=resolved_settings.r2_endpoint_url,
+        )
+        billing_provider = StripeBilling(
+            stripe_key=resolved_settings.stripe_key,
+            endpoint_secret=resolved_settings.stripe_endpoint_secret,
+        )
+        ocr_provider = ClaudeOCR()
+        mailer_provider = TransactionalMailer()
+
+        analytics_provider = None
+        if resolved_settings.ga4_measurement_id and resolved_settings.ga4_api_secret:
+            analytics_provider = GA4Analytics(
+                measurement_id=resolved_settings.ga4_measurement_id,
+                api_secret=resolved_settings.ga4_api_secret,
+            )
+
+        app.dependency_overrides[get_storage] = lambda sp=storage_provider: sp
+        app.dependency_overrides[get_billing] = lambda bp=billing_provider: bp
+        app.dependency_overrides[get_ocr] = lambda op=ocr_provider: op
+        if analytics_provider is not None:
+            app.dependency_overrides[get_analytics] = lambda ap=analytics_provider: ap
+        app.dependency_overrides[get_mailer] = lambda mp=mailer_provider: mp
+        object.__setattr__(resolved_settings, "ocr_enabled", True)
+
+    else:
+        storage_provider = LocalStorage(
+            base_dir=resolved_settings.local_upload_dir,
+            base_url=resolved_settings.local_upload_base_url,
+        )
+        app.dependency_overrides[get_storage] = lambda sp=storage_provider: sp
+
+    return app
+
+
+# Uvicorn compatibility: allow ``uvicorn server.app:app``
+app = create_app()

compair_core/server/deps.py

@@ -0,0 +1,77 @@
+"""Dependency entry points for features that differ by edition."""
+from __future__ import annotations
+
+from functools import lru_cache
+
+from fastapi import Depends
+
+from .providers.console_mailer import ConsoleMailer
+from .providers.contracts import Analytics, BillingProvider, Mailer, OCRProvider, StorageProvider
+from .providers.http_ocr import HTTPOCR
+from .providers.local_storage import LocalStorage
+from .providers.noop_analytics import NoopAnalytics
+from .providers.noop_billing import NoopBilling
+from .providers.noop_ocr import NoopOCR
+from .settings import Settings, get_settings
+
+
+@lru_cache
+def _local_storage_factory(base_dir: str, base_url: str) -> LocalStorage:
+    return LocalStorage(base_dir=base_dir, base_url=base_url)
+
+
+@lru_cache
+def _noop_billing() -> NoopBilling:
+    return NoopBilling()
+
+
+@lru_cache
+def _noop_ocr() -> NoopOCR:
+    return NoopOCR()
+
+
+@lru_cache
+def _http_ocr(endpoint: str, timeout: float) -> HTTPOCR:
+    return HTTPOCR(endpoint=endpoint, timeout=timeout)
+
+
+@lru_cache
+def _console_mailer() -> ConsoleMailer:
+    return ConsoleMailer()
+
+
+@lru_cache
+def _noop_analytics() -> NoopAnalytics:
+    return NoopAnalytics()
+
+
+def get_settings_dependency() -> Settings:
+    """Expose settings as a FastAPI dependency."""
+    return get_settings()
+
+
+
+def get_storage(
+    settings: Settings = Depends(get_settings_dependency),
+) -> StorageProvider:
+    return _local_storage_factory(settings.local_upload_dir, settings.local_upload_base_url)
+
+
+def get_billing() -> BillingProvider:
+    return _noop_billing()
+
+
+def get_ocr(
+    settings: Settings = Depends(get_settings_dependency),
+) -> OCRProvider:
+    if settings.ocr_enabled and settings.ocr_endpoint:
+        return _http_ocr(settings.ocr_endpoint, settings.ocr_request_timeout)
+    return _noop_ocr()
+
+
+def get_mailer() -> Mailer:
+    return _console_mailer()
+
+
+def get_analytics() -> Analytics:
+    return _noop_analytics()

compair_core/server/local_model/__init__.py

@@ -0,0 +1 @@
+"""Local model endpoints for the Core edition."""

compair_core/server/local_model/app.py

@@ -0,0 +1,87 @@
+"""Minimal FastAPI application serving local embedding and generation endpoints."""
+from __future__ import annotations
+
+import hashlib
+import os
+from typing import List
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI(title="Compair Local Model", version="0.1.0")
+
+_DEFAULT_DIM = 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:
+    EMBED_DIMENSION = int(_DIM_ENV)
+except ValueError:  # pragma: no cover - invalid configuration
+    EMBED_DIMENSION = _DEFAULT_DIM
+
+
+def _hash_embedding(text: str, dimension: int = EMBED_DIMENSION) -> List[float]:
+    if not text:
+        text = " "
+    digest = hashlib.sha256(text.encode("utf-8", "ignore")).digest()
+    vector: List[float] = []
+    while len(vector) < dimension:
+        for byte in digest:
+            vector.append((byte / 255.0) * 2 - 1)
+            if len(vector) == dimension:
+                break
+        digest = hashlib.sha256(digest).digest()
+    return vector
+
+
+class EmbedRequest(BaseModel):
+    text: str
+
+
+class EmbedResponse(BaseModel):
+    embedding: List[float]
+
+
+class GenerateRequest(BaseModel):
+    # Legacy format used by the CLI shim
+    system: str | None = None
+    prompt: str | None = None
+    verbosity: str | None = None
+
+    # Core API payload (document + references)
+    document: str | None = None
+    references: List[str] | None = None
+    length_instruction: str | None = None
+
+
+class GenerateResponse(BaseModel):
+    feedback: str
+
+
+@app.post("/embed", response_model=EmbedResponse)
+def embed(request: EmbedRequest) -> EmbedResponse:
+    return EmbedResponse(embedding=_hash_embedding(request.text))
+
+
+@app.post("/generate", response_model=GenerateResponse)
+def generate(request: GenerateRequest) -> GenerateResponse:
+    # Determine the main text input (document or prompt)
+    text_input = request.document or request.prompt or ""
+    text_input = text_input.strip()
+
+    if not text_input:
+        return GenerateResponse(feedback="NONE")
+
+    first_sentence = text_input.split("\n", 1)[0][:200]
+    verbosity = request.length_instruction or request.verbosity or "brief response"
+    ref_snippet = ""
+    if request.references:
+        top_ref = (request.references[0] or "").strip()
+        if top_ref:
+            ref_snippet = f" Reference: {top_ref[:160]}"
+
+    feedback = f"[local-feedback] {verbosity}: {first_sentence}{ref_snippet}".strip()
+    return GenerateResponse(feedback=feedback or "NONE")

compair_core/server/local_model/ocr.py

@@ -0,0 +1,107 @@
+"""Minimal OCR endpoint leveraging pytesseract when available."""
+from __future__ import annotations
+
+import io
+import os
+from typing import Any, Dict
+
+from fastapi import FastAPI, File, HTTPException, UploadFile
+
+app = FastAPI(title="Compair Local OCR", version="0.1.0")
+
+try:  # Optional dependency
+    import pytesseract  # type: ignore
+    from pytesseract import TesseractNotFoundError  # type: ignore
+    from PIL import Image  # type: ignore
+except ImportError:  # pragma: no cover - optional
+    pytesseract = None  # type: ignore
+    TesseractNotFoundError = OSError  # type: ignore
+    Image = None  # type: ignore
+
+try:  # Optional: text extraction for PDFs
+    from pypdf import PdfReader  # type: ignore
+except ImportError:  # pragma: no cover - optional
+    PdfReader = None  # type: ignore
+
+_OCR_FALLBACK = os.getenv("COMPAIR_LOCAL_OCR_FALLBACK", "text")  # text | none
+_TESSERACT_AVAILABLE = False
+if pytesseract is not None and Image is not None:
+    try:  # pragma: no cover - runtime probe
+        pytesseract.get_tesseract_version()
+        _TESSERACT_AVAILABLE = True
+    except (TesseractNotFoundError, OSError):
+        _TESSERACT_AVAILABLE = False
+
+
+def _is_pdf(data: bytes) -> bool:
+    return data.startswith(b"%PDF")
+
+
+def _extract_pdf_text(data: bytes) -> str:
+    if PdfReader is None:
+        return ""
+    try:
+        reader = PdfReader(io.BytesIO(data))
+        parts = []
+        for page in reader.pages:
+            text = page.extract_text() or ""
+            if text.strip():
+                parts.append(text)
+        return "\n".join(parts).strip()
+    except Exception:
+        return ""
+
+
+def _fallback_text(data: bytes) -> str:
+    if _OCR_FALLBACK == "text":
+        try:
+            return data.decode("utf-8")
+        except UnicodeDecodeError:
+            return data.decode("latin-1", errors="ignore")
+    return ""
+
+
+def _extract_text(data: bytes) -> tuple[str, bool]:
+    provider_used = False
+    if _is_pdf(data):
+        if PdfReader is not None:
+            provider_used = True
+            text = _extract_pdf_text(data)
+            if text:
+                return text, provider_used
+        if pytesseract is None or Image is None:
+            text = _fallback_text(data)
+            if text:
+                provider_used = True
+            return text, provider_used
+
+    if pytesseract is not None and Image is not None and _TESSERACT_AVAILABLE:
+        provider_used = True
+        try:
+            image = Image.open(io.BytesIO(data))
+            text = pytesseract.image_to_string(image)
+            if text:
+                return text, provider_used
+        except Exception:
+            pass
+
+    text = _fallback_text(data)
+    if text:
+        provider_used = True
+    return text, provider_used
+
+
+@app.post("/ocr-file")
+async def ocr_file(file: UploadFile = File(...)) -> Dict[str, Any]:
+    payload = await file.read()
+    text, provider_available = _extract_text(payload)
+    if not provider_available:
+        if pytesseract is not None and not _TESSERACT_AVAILABLE:
+            detail = "Tesseract CLI is not installed or accessible. Install it (e.g., via your package manager) or run the container image, then retry."
+        else:
+            detail = "OCR extraction failed. Supported formats include PDFs (text-only) and common image types."
+        raise HTTPException(
+            status_code=501,
+            detail=detail,
+        )
+    return {"extracted_text": text or "NONE"}

compair_core/server/providers/console_mailer.py

@@ -0,0 +1,9 @@
+"""Console mailer used in Core builds to avoid delivering real email."""
+from __future__ import annotations
+
+from typing import Iterable
+
+
+class ConsoleMailer:
+    def send(self, subject: str, sender: str, receivers: Iterable[str], html: str) -> None:
+        print(f"[MAIL] {subject} -> {list(receivers)}")

compair_core/server/providers/contracts.py

@@ -0,0 +1,66 @@
+"""Provider protocol definitions shared across editions."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import BinaryIO, Iterable, Mapping, Protocol
+
+
+@dataclass(slots=True)
+class BillingSession:
+    """Represents the result of creating a checkout session."""
+
+    id: str
+    url: str
+
+
+class StorageProvider(Protocol):
+    def put_file(self, key: str, fileobj: BinaryIO, content_type: str) -> str: ...
+
+    def get_file(self, key: str) -> tuple[BinaryIO, str]: ...
+
+    def build_url(self, key: str) -> str: ...
+
+
+class BillingProvider(Protocol):
+    def ensure_customer(self, *, user_email: str, user_id: str) -> str: ...
+
+    def create_checkout_session(
+        self,
+        *,
+        customer_id: str,
+        price_id: str,
+        qty: int,
+        success_url: str,
+        cancel_url: str,
+        metadata: Mapping[str, str] | None = None,
+    ) -> BillingSession: ...
+
+    def retrieve_session(self, session_id: str) -> BillingSession: ...
+
+    def get_checkout_url(self, session_id: str) -> str: ...
+
+    def create_customer_portal(self, *, customer_id: str, return_url: str) -> str: ...
+
+    def create_coupon(self, amount: int) -> str: ...
+
+    def apply_coupon(self, *, customer_id: str, coupon_id: str) -> None: ...
+
+    def construct_event(self, payload: bytes, signature: str | None) -> Mapping[str, object]: ...
+
+
+class OCRProvider(Protocol):
+    def submit(
+        self, *, user_id: str, filename: str, data: bytes, document_id: str | None
+    ) -> str: ...
+
+    def status(self, task_id: str) -> Mapping[str, object]: ...
+
+
+class Mailer(Protocol):
+    def send(self, subject: str, sender: str, receivers: Iterable[str], html: str) -> None: ...
+
+
+class Analytics(Protocol):
+    def track(
+        self, event_name: str, user_id: str, params: Mapping[str, object] | None = None
+    ) -> None: ...

compair_core/server/providers/http_ocr.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import threading
+import uuid
+from typing import Dict
+
+import requests
+
+
+class HTTPOCR:
+    """Simple OCR provider that forwards uploads to an HTTP endpoint."""
+
+    def __init__(self, endpoint: str, *, timeout: float = 30.0) -> None:
+        self.endpoint = endpoint
+        self.timeout = timeout
+        self._lock = threading.Lock()
+        self._results: Dict[str, dict[str, object]] = {}
+
+    def submit(
+        self,
+        *,
+        user_id: str,
+        filename: str,
+        data: bytes,
+        document_id: str | None,
+    ) -> str:
+        files = {"file": (filename, data)}
+        response = requests.post(self.endpoint, files=files, timeout=self.timeout)
+        response.raise_for_status()
+        payload: dict[str, object]
+        try:
+            payload = response.json()
+        except ValueError:
+            payload = {"extracted_text": response.text}
+
+        extracted = (
+            payload.get("extracted_text")
+            or payload.get("text")
+            or payload.get("content")
+        )
+        if not extracted:
+            raise RuntimeError("OCR endpoint returned an empty response.")
+
+        task_id = str(uuid.uuid4())
+        result = {
+            "status": "completed",
+            "extracted_text": extracted,
+            "document_id": document_id,
+            "user_id": user_id,
+        }
+        with self._lock:
+            self._results[task_id] = result
+        return task_id
+
+    def status(self, task_id: str) -> dict[str, object]:
+        with self._lock:
+            result = self._results.get(task_id)
+        if result is None:
+            return {"status": "unknown", "task_id": task_id}
+        return result