prism-models 0.1.0__py3-none-any.whl

prism_models/content.py

@@ -0,0 +1,250 @@
+import enum
+from typing import Any, Optional
+
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Column,
+    Enum,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Table,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from prism_models.base import Base, BaseModel
+from prism_models.chat import Contact
+from prism_models.qdrant import QdrantVectorPayload, PydanticType
+
+
+class DocumentStatus(str, enum.Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+class DocumentPublishStatus(str, enum.Enum):
+    PREVIEW = "preview"
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+class SyncFrequency(str, enum.Enum):
+    HOURLY = "hourly"
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    REALTIME = "realtime"
+
+
+class ChunkStrategy(str, enum.Enum):
+    FIXED_SIZE = "fixed_size"
+    SEMANTIC = "semantic"
+    PARAGRAPH = "paragraph"
+    DOCLING_HYBRID = "docling_hybrid"
+    LLM = "llm"
+
+
+class ProvenanceType(str, enum.Enum):
+    GENERATED = "generated"
+    MANUAL = "manual"
+    VERIFIED = "verified"
+
+
+class SourceName(str, enum.Enum):
+    S3 = "S3"
+    SHARE_POINT = "SHARE_POINT"
+    GRID = "GRID"
+    GRID_DESTINATION_REPORT = "GRID_DESTINATION_REPORT"
+    GRID_EVENT_REPORT = "GRID_EVENT_REPORT"
+    CRM = "CRM"
+    CONFLUENCE = "CONFLUENCE"
+    CUSTOM = "CUSTOM"
+    TRAVEL_ADVISORY = "TRAVEL_ADVISORY"
+    MSA = "MSA"
+
+class Source(BaseModel):
+    """Source model for tracking origin of content."""
+
+    name: Mapped[str] = mapped_column(
+        String(255),
+        nullable=False,
+        unique=True,
+        index=True
+    )
+    
+    type: Mapped[SourceName] = mapped_column(
+        Enum(SourceName, native_enum=False),
+        nullable=True,
+        index=True,
+        default=SourceName.CUSTOM
+    )
+
+    connection_config: Mapped[dict[str, Any] | None] = mapped_column(
+        JSON, nullable=True, default=dict
+    )
+    additional_data: Mapped[dict[str, Any] | None] = mapped_column(
+        "additional_data", JSON, nullable=True, default=dict
+    )
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+
+    # New fields (nullable, only meaningful if name == S3)
+    s3_bucket: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    s3_directory: Mapped[str | None] = mapped_column(String(2048), nullable=True)
+
+    # One-to-one relationship to Collection via unique FK - NOTE NOT UNIQUE
+    collection_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("collection.id"), nullable=False, unique=True, index=True
+    )
+    collection: Mapped[Optional["Collection"]] = relationship(
+        "Collection", back_populates="source", uselist=False
+    )
+
+
+    def __repr__(self):
+        return f"<Source(id={getattr(self, 'id', None)}, name='{self.name}')>"
+
+
+class Collection(BaseModel):
+    """Collection model for grouping documents."""
+
+    name: Mapped[str] = mapped_column(String(200), nullable=False, index=True)
+    description: Mapped[str | None] = mapped_column(Text, nullable=True)
+    additional_data: Mapped[dict[str, Any] | None] = mapped_column("additional_data", JSON, nullable=True, default=dict)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    owner_id: Mapped[int | None] = mapped_column(ForeignKey("contact.id"), nullable=True, index=True)
+    # Relationships
+    owner: Mapped[Optional["Contact"]] = relationship("Contact")
+    documents: Mapped[list["CollectionDocument"]] = relationship(back_populates="collection")
+    # One-to-one backref to Source
+    source: Mapped[Optional["Source"]] = relationship(
+        "Source", back_populates="collection", uselist=False
+    )
+
+    __table_args__ = (UniqueConstraint("name", name="uq_collection_name"),)
+
+    def __repr__(self):
+        return f"<Collection(id={self.id}, name='{self.name}', is_active={self.is_active})>"
+
+
+class Document(BaseModel):
+    """Document model for storing various types of content."""
+
+    title: Mapped[str] = mapped_column(String(500), nullable=False, index=True)
+    source_id: Mapped[int] = mapped_column(Integer, ForeignKey("source.id"), nullable=False, index=True)
+    parent_document_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("document.id"), nullable=True, index=True)
+
+    uploaded_by_id: Mapped[int | None] = mapped_column(ForeignKey("contact.id"), nullable=True, index=True)
+    file_path_s3: Mapped[str | None] = mapped_column(String(2048), nullable=True)
+    file_hash: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    file_size: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    version: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
+    is_latest: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    additional_data: Mapped[dict[str, Any] | None] = mapped_column("additional_data", JSON, nullable=True, default=dict)
+    status: Mapped[DocumentStatus] = mapped_column(String(50), nullable=False, index=True, default=DocumentStatus.PENDING)
+    publish_status: Mapped[DocumentPublishStatus] = mapped_column(String(50), nullable=False, index=True, default=DocumentPublishStatus.PREVIEW)
+    markdown_file_path_s3:Mapped[str | None] = mapped_column(String(2048), nullable=True)
+    chunk_config_id: Mapped[int | None] = mapped_column(ForeignKey("chunk_config.id", ondelete="SET NULL"), nullable=True)
+    sharepoint_drive_item_id: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    # Relationships
+    source: Mapped["Source"] = relationship("Source")
+    # Use string-based remote_side to avoid resolving Python built-in id
+    parent_document: Mapped[Optional["Document"]] = relationship("Document", remote_side="Document.id")
+    chunk_config: Mapped[Optional["ChunkConfig"]] = relationship("ChunkConfig", back_populates="documents")
+    uploaded_by: Mapped[Optional["Contact"]] = relationship("Contact", foreign_keys=[uploaded_by_id])
+    collections: Mapped[list["CollectionDocument"]] = relationship(back_populates="document")
+    chunks: Mapped[list["Chunk"]] = relationship(back_populates="document", cascade="all, delete-orphan")
+    qa_pairs: Mapped[list["QAPair"]] = relationship(back_populates="document", cascade="all, delete-orphan")
+
+
+    def __repr__(self):
+        return f"<Document(id={self.id}, title='{self.title[:50]}...')>"
+
+
+class CollectionDocument(BaseModel):
+    """Association object between Collections and Documents."""
+
+    collection_id: Mapped[int] = mapped_column(ForeignKey("collection.id"), nullable=False)
+    document_id: Mapped[int] = mapped_column(ForeignKey("document.id"), nullable=False)
+
+    collection: Mapped["Collection"] = relationship(back_populates="documents")
+    document: Mapped["Document"] = relationship(back_populates="collections")
+
+    __table_args__ = (UniqueConstraint("collection_id", "document_id", name="uq_collection_document"),)
+
+
+class IntegrationConfig(BaseModel):
+    source_id: Mapped[int] = mapped_column(ForeignKey("source.id"), nullable=False, index=True)
+    chunk_config_id: Mapped[int | None] = mapped_column(ForeignKey("chunk_config.id"))
+    external_id: Mapped[str | None] = mapped_column(String(255))
+    target_collection_ids: Mapped[list[int] | None] = mapped_column(ARRAY(Integer))
+    sync_frequency: Mapped[SyncFrequency] = mapped_column(String(20), default=SyncFrequency.DAILY)
+    sync_enabled: Mapped[bool] = mapped_column(Boolean, default=True)
+
+    source: Mapped["Source"] = relationship()
+    chunk_config: Mapped["ChunkConfig"] = relationship()
+
+
+class ChunkConfig(BaseModel):
+    name: Mapped[str] = mapped_column(String(255))
+    strategy: Mapped[ChunkStrategy] = mapped_column(String(50), default=ChunkStrategy.DOCLING_HYBRID)
+    chunk_size: Mapped[int] = mapped_column(Integer, default=600)
+    chunk_overlap: Mapped[int] = mapped_column(Integer, default=60)
+    internal_qa_enabled: Mapped[bool] = mapped_column(Boolean, default=False)
+    external_qa_enabled: Mapped[bool] = mapped_column(Boolean, default=False)
+    internal_qa_prompt: Mapped[str | None] = mapped_column(Text)
+    external_qa_prompt: Mapped[str | None] = mapped_column(Text)
+    additional_data: Mapped[dict[str, Any] | None] = mapped_column("additional_data", JSON, nullable=True, default=dict)
+    is_template: Mapped[bool] = mapped_column(Boolean, default=False)
+
+    documents: Mapped[list["Document"]] = relationship("Document", back_populates="chunk_config")
+
+
+qa_pair_chunk_association_table = Table(
+    "qa_pair_chunk_association",
+    Base.metadata,
+    Column("qa_pair_id", ForeignKey("qa_pair.id"), primary_key=True),
+    Column("chunk_id", ForeignKey("chunk.id"), primary_key=True),
+)
+
+
+class Chunk(BaseModel):
+    document_id: Mapped[int] = mapped_column(ForeignKey("document.id"), nullable=False, index=True)
+    chunk_config_id: Mapped[int | None] = mapped_column(ForeignKey("chunk_config.id"))
+    text: Mapped[str] = mapped_column(Text, nullable=False)
+    text_hash: Mapped[str | None] = mapped_column(String(64), index=True)
+
+    document: Mapped["Document"] = relationship(back_populates="chunks")
+    chunk_config: Mapped[Optional["ChunkConfig"]] = relationship()
+    qa_pairs: Mapped[list["QAPair"]] = relationship(secondary=qa_pair_chunk_association_table, back_populates="source_chunks")
+    vector: Mapped[Optional["Vector"]] = relationship(back_populates="chunk", uselist=False, cascade="all, delete-orphan")
+
+
+class QAPair(BaseModel):
+    document_id: Mapped[int] = mapped_column(ForeignKey("document.id"), nullable=False, index=True)
+    question: Mapped[str] = mapped_column(Text, nullable=False)
+    answer: Mapped[str] = mapped_column(Text, nullable=False)
+    provenance: Mapped[ProvenanceType] = mapped_column(String(50), default=ProvenanceType.GENERATED)
+    confidence_score: Mapped[float | None] = mapped_column(Float, nullable=True)
+    document: Mapped["Document"] = relationship(back_populates="qa_pairs")
+    source_chunks: Mapped[list["Chunk"]] = relationship(secondary=qa_pair_chunk_association_table, back_populates="qa_pairs")
+    vector: Mapped[Optional["Vector"]] = relationship(back_populates="qa_pair", uselist=False, cascade="all, delete-orphan")
+
+class Vector(BaseModel):
+    chunk_id: Mapped[int] = mapped_column(ForeignKey("chunk.id"), nullable=True, unique=True)
+    qa_pair_id: Mapped[int] = mapped_column(ForeignKey("qa_pair.id"), nullable=True, unique=True)
+    model: Mapped[str] = mapped_column(String(100))
+    qdrant_point_id: Mapped[str | None] = mapped_column(String(100), unique=True)
+    vector_embeddings: Mapped[list[float] | None] = mapped_column(ARRAY(Float), nullable=True)
+    additional_data: Mapped[QdrantVectorPayload | None] = mapped_column(
+        PydanticType(QdrantVectorPayload), 
+        nullable=True
+    )
+    
+
+    chunk: Mapped["Chunk"] = relationship(back_populates="vector")
+    qa_pair: Mapped["QAPair"] = relationship(back_populates="vector")

prism_models/feedback.py

@@ -0,0 +1,145 @@
+import enum
+from datetime import datetime
+from typing import Any, Optional
+
+from sqlalchemy import (
+    JSON,
+    TIMESTAMP,
+    Boolean,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    Text,
+    func,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from prism_models.base import BaseModel
+from prism_models.chat import Contact, ConversationMessage
+from prism_models.content import Chunk, QAPair
+
+# MessageFeedback model removed - using new Feedback model below
+
+
+class FeedbackType(str, enum.Enum):
+    THUMBS_DOWN = "thumbs_down"
+    CORRECTION = "correction"
+    ENHANCEMENT = "enhancement"
+    DELETION = "deletion"
+    ACCURACY = "accuracy"
+    COMPLETENESS = "completeness"
+
+
+class FeedbackStatus(str, enum.Enum):
+    PENDING = "pending"
+    APPROVED = "approved"
+    REJECTED = "rejected"
+    IMPLEMENTED = "implemented"
+
+
+class FeedbackConfidence(str, enum.Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    ABSOLUTE = "absolute"
+
+
+class AugmentationAction(str, enum.Enum):
+    CREATE = "create"
+    CORRECT = "correct"
+    ENHANCE = "enhance"
+    DELETE = "delete"
+
+
+class AugmentationStatus(str, enum.Enum):
+    PENDING = "pending"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class AnalysisType(str, enum.Enum):
+    CONTENT_ANALYSIS = "content_analysis"
+    IMPACT_ASSESSMENT = "impact_assessment"
+    ROOT_CAUSE_ANALYSIS = "root_cause_analysis"
+
+
+class Feedback(BaseModel):
+    manager_id: Mapped[int] = mapped_column(Integer, ForeignKey("contact.id"), nullable=False, index=True)
+    chunk_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("chunk.id"), nullable=True, index=True)
+    qa_pair_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("qa_pair.id"), nullable=True, index=True)
+    # Link feedback to a specific conversation message
+    message_id: Mapped[int | None] = mapped_column(
+        Integer,
+        ForeignKey("conversation_message.id"),
+        nullable=True,
+        index=True,
+    )
+    assigned_reviewer_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("contact.id"), nullable=True, index=True)
+
+    authority_domain: Mapped[str | None] = mapped_column(String(255))
+    confidence_level: Mapped[FeedbackConfidence | None] = mapped_column(String(50))
+    feedback_type: Mapped[FeedbackType] = mapped_column(String(50), nullable=False)
+
+    # user query, agent response, correction note,
+    query: Mapped[str | None] = mapped_column(Text)
+    provided_response: Mapped[str | None] = mapped_column(Text)
+    correction: Mapped[str | None] = mapped_column(Text)
+    requires_review: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    status: Mapped[FeedbackStatus] = mapped_column(String(50), default=FeedbackStatus.PENDING, nullable=False, index=True)
+    admin_notes: Mapped[str | None] = mapped_column(Text)
+    reviewed_at: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True))
+    routed: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+    # Relationships
+    manager: Mapped["Contact"] = relationship(foreign_keys=[manager_id])
+    chunk: Mapped[Optional["Chunk"]] = relationship()
+    qa_pair: Mapped[Optional["QAPair"]] = relationship()
+    message: Mapped[Optional["ConversationMessage"]] = relationship()
+    assigned_reviewer: Mapped[Optional["Contact"]] = relationship(foreign_keys=[assigned_reviewer_id])
+
+    analysis: Mapped[list["FeedbackAnalysis"]] = relationship(back_populates="feedback", cascade="all, delete-orphan")
+    augmentations: Mapped[list["Augmentation"]] = relationship(back_populates="feedback", cascade="all, delete-orphan")
+
+    def __repr__(self):
+        return f"<Feedback(id={self.id}, type='{self.feedback_type}', status='{self.status}')>"
+
+
+class FeedbackAnalysis(BaseModel):
+    __tablename__ = "feedback_analysis"
+    feedback_id: Mapped[int] = mapped_column(Integer, ForeignKey("feedback.id"), nullable=False, index=True)
+
+    analysis_type: Mapped[AnalysisType] = mapped_column(String(50), nullable=False)
+    llm_response: Mapped[dict[str, Any] | None] = mapped_column(JSON)
+    confidence_score: Mapped[float | None] = mapped_column(Float)
+    model_used: Mapped[str | None] = mapped_column(String(255))
+    analyzed_at: Mapped[datetime] = mapped_column(TIMESTAMP(timezone=True), server_default=func.now(), nullable=False)
+    approved: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    reason_to_reject: Mapped[str | None] = mapped_column(Text)
+
+    # Relationships
+    feedback: Mapped["Feedback"] = relationship(back_populates="analysis")
+
+    def __repr__(self):
+        return f"<FeedbackAnalysis(id={self.id}, feedback_id={self.feedback_id}, type='{self.analysis_type}')>"
+
+
+class Augmentation(BaseModel):
+    feedback_id: Mapped[int] = mapped_column(Integer, ForeignKey("feedback.id"), nullable=False, index=True)
+    original_chunk_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("chunk.id"), nullable=True)
+    original_qa_pair_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("qa_pair.id"), nullable=True)
+    generated_chunk_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("chunk.id"), nullable=True)
+    generated_qa_pair_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("qa_pair.id"), nullable=True)
+
+    action_type: Mapped[AugmentationAction] = mapped_column(String(50), nullable=False)
+    change_summary: Mapped[dict[str, Any] | None] = mapped_column(JSON)
+    status: Mapped[AugmentationStatus] = mapped_column(String(50), default=AugmentationStatus.PENDING, nullable=False, index=True)
+    # Relationships
+    feedback: Mapped["Feedback"] = relationship(back_populates="augmentations")
+    original_chunk: Mapped[Optional["Chunk"]] = relationship(foreign_keys=[original_chunk_id])
+    original_qa_pair: Mapped[Optional["QAPair"]] = relationship(foreign_keys=[original_qa_pair_id])
+    generated_chunk: Mapped[Optional["Chunk"]] = relationship(foreign_keys=[generated_chunk_id])
+    generated_qa_pair: Mapped[Optional["QAPair"]] = relationship(foreign_keys=[generated_qa_pair_id])
+
+    def __repr__(self):
+        return f"<Augmentation(id={self.id}, action='{self.action_type}', status='{self.status}')>"

prism_models/migration/README

@@ -0,0 +1 @@
+Generic single-database configuration.

prism_models/migration/env.py

@@ -0,0 +1,131 @@
+import asyncio
+import sys
+from logging.config import fileConfig
+from pathlib import Path
+
+from alembic import context
+from sqlalchemy import pool
+from sqlalchemy.engine import Connection
+from sqlalchemy.ext.asyncio import create_async_engine
+
+# Add prism-models to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+# Import models and configuration - after path setup
+from prism_models.config import settings
+from prism_models.base import Base
+
+# Import all models to ensure they're registered
+import prism_models.agent_profile
+import prism_models.chat
+import prism_models.content
+import prism_models.feedback
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Set the SQLAlchemy URL from environment
+if not config.get_main_option("sqlalchemy.url"):
+    config.set_main_option("sqlalchemy.url", settings.PG_DATABASE_URL_PRISM)
+
+# Import all models to ensure they're registered with Base.metadata
+
+# Add your model's MetaData object here for 'autogenerate' support
+target_metadata = Base.metadata
+
+# Other values from the config can be acquired as needed
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        compare_type=True,  # Compare column types
+        compare_server_default=True,  # Compare server defaults
+        include_schemas=True,  # Include schema-specific tables
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def do_run_migrations(connection: Connection) -> None:
+    """Run migrations with the given connection."""
+    context.configure(
+        connection=connection,
+        target_metadata=target_metadata,
+        compare_type=True,  # Compare column types for better autogeneration
+        compare_server_default=True,  # Compare server defaults
+        include_schemas=True,  # Include schema-specific tables (chat schema)
+        render_as_batch=False,  # PostgreSQL doesn't need batch mode
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+async def run_async_migrations() -> None:
+    """Run migrations in async mode for async engines."""
+    # Use async engine for PostgreSQL
+    connectable = create_async_engine(
+        settings.PG_DATABASE_URL_PRISM,
+        poolclass=pool.NullPool,
+        echo=settings.is_development,
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+    await connectable.dispose()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    For async databases, we use run_async_migrations.
+    For sync databases, we use the traditional approach.
+    """
+    database_url = config.get_main_option("sqlalchemy.url")
+
+    if "asyncpg" in database_url or "aiosqlite" in database_url:
+        # Async database - use async migrations
+        asyncio.run(run_async_migrations())
+    else:
+        # Sync database - use traditional approach
+        from sqlalchemy import engine_from_config
+
+        connectable = engine_from_config(
+            config.get_section(config.config_ini_section, {}),
+            prefix="sqlalchemy.",
+            poolclass=pool.NullPool,
+        )
+
+        with connectable.connect() as connection:
+            do_run_migrations(connection)
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

prism_models/migration/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}