compair-core 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

compair/models.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import binascii
+import hashlib
+import os
+import secrets
+from datetime import datetime, timezone
+from uuid import uuid4
+
+from pgvector.sqlalchemy import Vector
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Identity,
+    Integer,
+    String,
+    Table,
+    Text,
+)
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,
+    MappedAsDataclass,
+    mapped_column,
+    relationship,
+)
+
+
+class Base(DeclarativeBase, MappedAsDataclass):
+    pass
+
+
+class BaseObject(Base):
+    __abstract__ = True
+
+
+class User(Base):
+    __tablename__ = "user"
+    __table_args__ = {"schema": "public"}
+
+    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,
+    )
+
+    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"
+    __table_args__ = {"schema": "public"}
+
+    id: Mapped[str] = mapped_column(String(128), primary_key=True, init=True)
+    user_id: Mapped[str] = mapped_column(ForeignKey("public.user.user_id", ondelete="CASCADE"), index=True)
+    datetime_created: Mapped[datetime]
+    datetime_valid_until: Mapped[datetime]
+
+
+class Group(BaseObject):
+    __tablename__ = "group"
+    __table_args__ = {"schema": "public"}
+
+    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")
+
+    __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"
+    __table_args__ = {"schema": "public"}
+
+    admin_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("public.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"
+    __table_args__ = {"schema": "public"}
+
+    request_id: Mapped[int] = mapped_column(Identity(), primary_key=True, autoincrement=True, init=False)
+    user_id: Mapped[str] = mapped_column(ForeignKey("public.user.user_id", ondelete="CASCADE"))
+    group_id: Mapped[str] = mapped_column(ForeignKey("public.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"
+    __table_args__ = {"schema": "public"}
+
+    invitation_id: Mapped[int] = mapped_column(Integer, Identity(), primary_key=True, autoincrement=True, init=False)
+    group_id: Mapped[str] = mapped_column(ForeignKey("public.group.group_id", ondelete="CASCADE"))
+    inviter_id: Mapped[str] = mapped_column(ForeignKey("public.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"
+    __table_args__ = {"schema": "public"}
+
+    document_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    user_id: Mapped[str] = mapped_column(ForeignKey("public.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]
+    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)
+    embedding = mapped_column(Vector(1536))
+
+    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"
+    __table_args__ = {"schema": "public"}
+
+    note_id: Mapped[str] = mapped_column(String(36), primary_key=True, init=False, default=lambda: str(uuid4()))
+    document_id: Mapped[str] = mapped_column(ForeignKey("public.document.document_id", ondelete="CASCADE"), index=True)
+    author_id: Mapped[str] = mapped_column(ForeignKey("public.user.user_id", ondelete="CASCADE"), index=True)
+    group_id: Mapped[str | None] = mapped_column(ForeignKey("public.group.group_id", ondelete="CASCADE"), index=True, nullable=True)
+    content: Mapped[str] = mapped_column(Text)
+    datetime_created: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc))
+    embedding = mapped_column(Vector(1536))
+
+    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"
+    __table_args__ = {"schema": "public"}
+
+    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("public.document.document_id", ondelete="CASCADE"), index=True, nullable=True)
+    note_id: Mapped[str | None] = mapped_column(ForeignKey("public.note.note_id", ondelete="CASCADE"), index=True, nullable=True)
+    chunk_type: Mapped[str] = mapped_column(String(16), default="document")
+    embedding = mapped_column(Vector(1536))
+
+    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"
+    __table_args__ = {"schema": "public"}
+
+    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("public.chunk.chunk_id", ondelete="CASCADE"), index=True)
+    reference_document_id: Mapped[str | None] = mapped_column(ForeignKey("public.document.document_id", ondelete="CASCADE"), index=True, nullable=True)
+    reference_note_id: Mapped[str | None] = mapped_column(ForeignKey("public.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"
+    __table_args__ = {"schema": "public"}
+
+    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("public.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")
+
+
+user_to_group_table = Table(
+    "user_to_group",
+    Base.metadata,
+    Column("user_id", ForeignKey("public.user.user_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("public.group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+
+admin_to_group_table = Table(
+    "admin_to_group",
+    Base.metadata,
+    Column("admin_id", ForeignKey("public.administrator.admin_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("public.group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+
+document_to_group_table = Table(
+    "document_to_group",
+    Base.metadata,
+    Column("document_id", ForeignKey("public.document.document_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("public.group.group_id", ondelete="CASCADE"), primary_key=True),
+)
+
+note_to_group_table = Table(
+    "note_to_group",
+    Base.metadata,
+    Column("note_id", ForeignKey("public.note.note_id", ondelete="CASCADE"), primary_key=True),
+    Column("group_id", ForeignKey("public.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/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/tasks.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import logging
+from typing import Mapping
+
+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):
+    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.")

compair/utils.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import secrets
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+try:
+    from compair_cloud.utils import log_activity as cloud_log_activity  # type: ignore
+except (ImportError, ModuleNotFoundError):
+    cloud_log_activity = None
+
+
+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:
+    if cloud_log_activity:
+        cloud_log_activity(
+            session=session,
+            user_id=user_id,
+            group_id=group_id,
+            action=action,
+            object_id=object_id,
+            object_name=object_name,
+            object_type=object_type,
+        )
+
+
+def aggregate_usage_by_user() -> dict[str, Any]:
+    if cloud_log_activity:
+        from compair_cloud.utils import aggregate_usage_by_user as cloud_usage  # type: ignore
+
+        return cloud_usage()
+    return {}
+
+
+def aggregate_service_resources() -> dict[str, Any]:
+    if cloud_log_activity:
+        from compair_cloud.utils import aggregate_service_resources as cloud_resources  # type: ignore
+
+        return cloud_resources()
+    return {}

{compair_core-0.3.1.dist-info → compair_core-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compair-core
-Version: 0.3.1
+Version: 0.3.3
 Summary: Open-source foundation of the Compair collaboration platform.
 Author: RocketResearch, Inc.
 License: MIT
@@ -96,8 +96,8 @@ See `compair_core/server/settings.py` for the full settings surface.
 ```bash
 python -m venv .venv
 source .venv/bin/activate
-pip install -e .[dev]
-uvicorn compair_core.server.app:create_app --factory --reload
+pip install -e ".[dev]"
+uvicorn compair.server.app:create_app --factory --reload
 ```
 
 The API will be available at http://127.0.0.1:8000 and supports the Swagger UI at `/docs`.
@@ -106,6 +106,8 @@ The API will be available at http://127.0.0.1:8000 and supports the Swagger UI a
 
 Core currently ships with a syntax sanity check (`python -m compileall ...`). You can add pytest or other tooling as needed.
 
+Release and packaging steps are documented in `docs/maintainers.md`.
+
 ## Reporting Issues
 
 Please open GitHub issues or PRs against this repository. If you are a Compair Cloud customer, reach out through your support channel for issues related to premium features.