letschatty 0.1.44__py3-none-any.whl

letschatty/__init__.py

@@ -0,0 +1,2 @@
+from .models import *
+from .services import *

letschatty/models/__init__.py

@@ -0,0 +1,4 @@
+from .messages import *
+from .events import *
+from .metrics import *
+from .utils import *

letschatty/models/company/empresa.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class Empresa(BaseModel):
+    name: str
+    phone_number_id: str = Field(alias="company_id")
+    bussiness_account_id: str
+    photo_url: str
+    meta_token: str
+    slack_channel_id: Optional[str] = Field(default=None)
+    phone_numbers_for_testing: list[str] = Field(default=[])

letschatty/models/events/__init__.py

@@ -0,0 +1,6 @@
+from .event_types import EventType
+from .contact_point import ContactPointEvent
+from .new_chat import NewChatEvent
+from .quality_scoring import QualityScoringEvent
+from .sale import SaleEvent
+from .template import TemplateEvent

letschatty/models/events/base.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, Field
+from enum import StrEnum
+from bson import ObjectId
+from datetime import datetime, timezone
+from typing import Dict, Any
+from .event_types import EventType
+from ..utils.types.identifier import StrObjectId
+import re
+
+class ChattyCloudEvent(BaseModel):
+    id: StrObjectId = Field(default_factory=lambda: str(ObjectId()), alias="_id")
+    source: str = Field(..., pattern=r"com\.chatty/[a-z-]+/[a-zA-Z0-9-]+")
+    specversion: str = Field(default="1.0")
+    type: EventType
+    time: datetime = Field(default_factory=lambda: datetime.now(tz=timezone.utc))
+    datacontenttype: str = Field(default="application/json")
+    data: Dict[str, Any]
+
+class ClientEvent(ChattyCloudEvent):
+    """Used for client related events, either management wise like an agent event or a business logic event like a new_chat."""
+    source: str = Field(..., pattern=r"com\.chatty/clients/[a-zA-Z0-9-]+")
+
+    @property
+    def client_id(self) -> str:
+        match = re.search(r"com\.chatty/clients/([a-zA-Z0-9-]+)", self.source)
+        if match:
+            return match.group(1)
+        raise ValueError("Invalid source format")
+
+class InternalEvent(ChattyCloudEvent):
+    """Used for internal events such as a new client, some billing, etc."""
+    source: str = Field(..., pattern=r"com\.chatty/internal/[a-z-]+")
+
+class BusinessLogicEvent(ClientEvent):
+    """Used for business logic events, such as a quality scoring."""
+    source: str = Field(..., pattern=r"com\.chatty/business-logic/[a-zA-Z0-9-]+")
+
+class BusinessLogicEventData(BaseModel):
+    channel_id : str
+    chat_id : StrObjectId
+    client_channel_user_id : str = Field(..., alias="waid")
+    company_phone_number_id : str
+    subtype : StrEnum
+
+    

letschatty/models/events/contact_point.py

@@ -0,0 +1,18 @@
+from .base import BusinessLogicEventData, BusinessLogicEvent
+from .event_types import EventType
+from ..utils.types.identifier import StrObjectId
+from enum import StrEnum
+
+class CPSubtype(StrEnum):
+    CREATED = "created"
+    UPDATED = "updated"
+    DELETED = "deleted"
+
+class ContactPointData(BusinessLogicEventData):
+    source_id: StrObjectId
+    new_chat : bool
+
+class ContactPointEvent(BusinessLogicEvent):
+    """Used for client related events, such as a new chat, a touchpoint, etc."""
+    type: EventType = EventType.CONTACT_POINT
+    data: ContactPointData

letschatty/models/events/event_types.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+class EventType(StrEnum):
+    CONTACT_POINT = "contact_point"
+    NEW_CHAT = "new_chat"
+    TEMPLATE = "template"
+    QUALITY_SCORING = "quality_scoring"
+    SALE = "sale"
+
+    
+

letschatty/models/events/new_chat.py

@@ -0,0 +1,11 @@
+from .base import BusinessLogicEventData, BusinessLogicEvent
+from .event_types import EventType
+from enum import StrEnum
+
+class NewChatData(BusinessLogicEventData):
+    is_inbound : bool
+
+class NewChatEvent(BusinessLogicEvent):
+    """Used for client related events, such as a new chat, a touchpoint, etc."""
+    type: EventType = EventType.NEW_CHAT
+    data: NewChatData

letschatty/models/events/quality_scoring.py

@@ -0,0 +1,16 @@
+from .base import BusinessLogicEventData, BusinessLogicEvent
+from .event_types import EventType
+from enum import StrEnum
+
+class QualityScore(StrEnum):
+    BAD = "bad"
+    GOOD = "good"
+    NEUTRAL = "neutral"
+
+class QualityScoringData(BusinessLogicEventData):
+    score : QualityScore
+
+class QualityScoringEvent(BusinessLogicEvent):
+    """Used for client related events, such as a new chat, a touchpoint, etc."""
+    type: EventType = EventType.QUALITY_SCORING
+    data: QualityScoringData

letschatty/models/events/sale.py

@@ -0,0 +1,16 @@
+from .base import BusinessLogicEventData, BusinessLogicEvent
+from .event_types import EventType
+from enum import StrEnum
+
+class SaleSubtype(StrEnum):
+    CREATED = "created"
+    UPDATED = "updated"
+    DELETED = "deleted"
+
+class SaleData(BusinessLogicEventData):
+    sale_id: str
+    
+class SaleEvent(BusinessLogicEvent):
+    """Used for client related events, such as a new chat, a touchpoint, etc."""
+    type: EventType = EventType.SALE
+    data: SaleData

letschatty/models/events/template.py

@@ -0,0 +1,19 @@
+from .base import BusinessLogicEventData, BusinessLogicEvent
+from .event_types import EventType
+from enum import StrEnum
+
+class TemplateSubtype(StrEnum):
+    WAITING = "waiting"
+    SENT = "sent"
+    DELIVERED = "delivered"
+    FAILED = "failed"
+    READ = "read"
+
+class TemplateData(BusinessLogicEventData):
+    message_id: str
+    template_name: str
+    
+class TemplateEvent(BusinessLogicEvent):
+    """Used for client related events, such as a new chat, a touchpoint, etc."""
+    type: EventType = EventType.TEMPLATE
+    data: TemplateData

letschatty/models/messages/__init__.py

@@ -0,0 +1,2 @@
+from .chatty_messages import *
+from .messages_request import *

letschatty/models/messages/chatty_messages/__init__.py

@@ -0,0 +1,17 @@
+from typing import Union, TypeAlias
+from .audio import AudioMessage
+from .document import DocumentMessage
+from .image import ImageMessage
+from .location import LocationMessage
+from .sticker import StickerMessage
+from .text import TextMessage
+from .video import VideoMessage
+from .unsupported import UnsupportedMessage
+from .reaction import ReactionMessage
+from .central_notification import CentralNotification
+from .contact import ContactMessage
+from .base import ChattyMessageJson
+# from .button import ButtonMessage
+
+ChattyMessage : TypeAlias = Union[AudioMessage, DocumentMessage, ImageMessage, LocationMessage, StickerMessage, TextMessage, VideoMessage, UnsupportedMessage, ReactionMessage, CentralNotification, ContactMessage]
+ChattyMediaMessage : TypeAlias = Union[AudioMessage, ImageMessage, VideoMessage, StickerMessage, DocumentMessage]

letschatty/models/messages/chatty_messages/audio.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from .schema import ChattyContentAudio
+from ...utils.types.message_types import MessageType
+
+class AudioMessage(Message):
+    type: MessageType = MessageType.AUDIO
+    content: ChattyContentAudio

letschatty/models/messages/chatty_messages/base/__init__.py

@@ -0,0 +1 @@
+from .chatty_message_json import ChattyMessageJson

letschatty/models/messages/chatty_messages/base/chatty_message_json.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any
+from datetime import datetime
+from ....utils.types.message_types import MessageType, MessageSubtype
+from ....utils.types.message_status_types import Status
+
+class Content(BaseModel):
+    pass
+
+class ChattyMessageJson(BaseModel):
+    """This is the database message model"""
+    id: str
+    created_at: datetime
+    updated_at: datetime
+    type: MessageType
+    status: Status
+    is_incoming_message: bool
+    content: Dict[str, Any] 
+    sent_by: Optional[str] = Field(default=None)
+    referral: Optional[Dict] = Field(default=None)
+    context: Optional[Dict] = Field(default=None)
+    subtype: Optional[str] = Field(default="")

letschatty/models/messages/chatty_messages/base/message_base.py

@@ -0,0 +1,117 @@
+from pydantic import BaseModel, Field, field_validator, ValidationInfo
+from datetime import datetime, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+from typing import Dict, Any, Optional
+
+from bson import ObjectId
+from ....utils import MessageType, Status, MessageSubtype
+from ..schema import ChattyContent, ChattyContext, ChattyReferral
+
+class Message(BaseModel):
+    created_at: datetime
+    updated_at: datetime
+    type: MessageType
+    content: ChattyContent
+    status: Status
+    is_incoming_message: bool
+    id: str = Field(default_factory=lambda: str(ObjectId()),description="Unique identifier for the message. In case it's a central notification or a message request (still not confirmed by external API) we'll use an object id as default. Also known as wamid form Meta")
+    sent_by: Optional[str] = Field(description="Email of the agent who sent the message. If it's incoming, it'll be None")
+    starred: bool = Field(default=False)
+    subtype: MessageSubtype = Field(default_factory=lambda: MessageSubtype.NONE)
+    referral: ChattyReferral = Field(default_factory=lambda: ChattyReferral.default())
+    context: ChattyContext = Field(default_factory=lambda: ChattyContext.default())
+    
+    def model_dump(self, *args, **kwargs) -> Dict[str, Any]:
+        """
+        Dump the message to a dictionary, with the option to convert datetimes to a specific timezone.
+        """
+        timezone = kwargs.pop('timezone', None)
+        data = super().model_dump(*args, **kwargs)
+        if timezone:
+            try:
+                tz = ZoneInfo(timezone)
+                data['created_at'] = self.created_at.astimezone(tz).isoformat()
+                data['updated_at'] = self.updated_at.astimezone(tz).isoformat()
+            except ZoneInfoNotFoundError:
+                raise ValueError(f"Invalid timezone: {timezone}")
+        return data
+
+    class ConfigDict:
+        validate_assignment = True
+    
+    @field_validator('sent_by', mode='before')
+    def validate_sent_by(cls, v: Optional[str], info: ValidationInfo) -> Optional[str]:
+        """Ensure that the sent_by field is not required for incoming messages, and that it's a valid email for outgoing messages."""
+        is_incoming = info.data.get('is_incoming_message', False)
+        if is_incoming:
+            return None
+        if not is_incoming and not v:
+            raise ValueError("sent_by is required for outgoing messages")
+        return v
+    
+    @field_validator('status', mode='before')
+    def validate_status(cls, v: Optional[str], info: ValidationInfo) -> Status:
+        """Status should be validated always, both instantiation and assignment"""
+        if isinstance(v, str):
+            return Status(v)
+        return v
+    
+    @field_validator('subtype', mode='before')
+    def validate_subtype(cls, v: Optional[str], info: ValidationInfo) -> MessageSubtype:
+        """If there's no subtype, we'll use the subtype NONE."""
+        if v is None or v == "":
+            return MessageSubtype.NONE
+        return v
+    
+    @field_validator('referral', mode='before')
+    def validate_referral(cls, v: Optional[Dict], info: ValidationInfo) -> ChattyReferral:
+        """If there's no referral, we'll use the referral default."""
+        if v is None or v == {}:
+            return ChattyReferral.default()
+        return v
+    
+    @field_validator('context', mode='before')
+    def validate_context(cls, v: Optional[Dict], info: ValidationInfo) -> ChattyContext:
+        """If there's no context, we'll use the context default."""
+        if v is None or v == {}:
+            return ChattyContext.default()
+        return v
+    
+    @field_validator('context', mode='after')
+    def validate_context_based_on_subtype(cls, v: ChattyContext, info: ValidationInfo) -> ChattyContext:
+        """We'll validate the context based on the subtype. 
+        And if there's no context, we'll use the context default."""
+        subtype = info.data.get('subtype')
+        if subtype == MessageSubtype.TEMPLATE:
+            if v.template_name is None:
+                raise ValueError("template_name is required for template messages")
+        elif subtype == MessageSubtype.CHATTY_RESPONSE:
+            if v.response_id is None:
+                raise ValueError("response_id is required for chatty_response messages")
+        return v
+
+    @field_validator('created_at', 'updated_at')
+    def ensure_utc(cls, v):
+        if isinstance(v, datetime):
+            return v.replace(tzinfo=timezone.utc) if v.tzinfo is None else v.astimezone(timezone.utc)
+        raise ValueError('must be a datetime')
+    
+    def _update_status(self, new_status: Status):
+        self.status = new_status
+        self.updated_at = datetime.now(timezone.utc)
+
+    def mark_as_read(self):
+        """Mark the message as read if not already failed."""
+        self._update_status(Status.READ)
+
+    def mark_as_delivered(self):
+        """Mark the message as delivered if it was sent."""
+        self._update_status(Status.DELIVERED)
+
+    def mark_as_failed(self):
+        """Mark the message as failed."""
+        self._update_status(Status.FAILED)
+
+    def mark_as_sent(self):
+        """Mark the message as sent."""
+        self._update_status(Status.SENT)

letschatty/models/messages/chatty_messages/button.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+
+
+class ButtonMessage(Message):
+   #TODO: Implementar
+   pass

letschatty/models/messages/chatty_messages/central_notification.py

@@ -0,0 +1,8 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentCentral
+
+class CentralNotification(Message):
+    type: str = MessageType.CENTRAL
+    content: ChattyContentCentral
+    

letschatty/models/messages/chatty_messages/contact.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentContacts
+
+class ContactMessage(Message):
+    type: MessageType = MessageType.CONTACT
+    content: ChattyContentContacts

letschatty/models/messages/chatty_messages/document.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentDocument
+
+class DocumentMessage(Message):
+    type: MessageType = MessageType.DOCUMENT
+    content: ChattyContentDocument

letschatty/models/messages/chatty_messages/image.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentImage
+
+class ImageMessage(Message):
+    type: MessageType = MessageType.IMAGE
+    content: ChattyContentImage

letschatty/models/messages/chatty_messages/interactive.py

@@ -0,0 +1,6 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+
+class InteractiveMessage(Message):
+    #TODO: Implementar
+    pass

letschatty/models/messages/chatty_messages/location.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentLocation
+
+class LocationMessage(Message):
+    type: str = MessageType.LOCATION.value
+    content: ChattyContentLocation

letschatty/models/messages/chatty_messages/reaction.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentReaction
+
+class ReactionMessage(Message):
+    type: MessageType = MessageType.REACTION
+    content: ChattyContentReaction

letschatty/models/messages/chatty_messages/schema/__init__.py

@@ -0,0 +1,18 @@
+from typing import TypeAlias, Union
+from .chatty_content.content_image import ChattyContentImage
+from .chatty_content.content_text import ChattyContentText
+from .chatty_content.content_video import ChattyContentVideo
+from .chatty_content.content_audio import ChattyContentAudio
+from .chatty_content.content_reaction import ChattyContentReaction
+from .chatty_content.content_location import ChattyContentLocation
+from .chatty_content.content_contacts import ChattyContentContacts
+from .chatty_content.content_document import ChattyContentDocument
+from .chatty_content.content_sticker import ChattyContentSticker
+from .chatty_content.content_central import ChattyContentCentral
+
+from .chatty_context.chatty_context import ChattyContext
+from .chatty_referal.chatty_referal import ChattyReferral
+
+
+ChattyContent : TypeAlias = Union[ChattyContentImage, ChattyContentText, ChattyContentVideo, ChattyContentAudio, ChattyContentReaction, ChattyContentLocation, ChattyContentContacts, ChattyContentDocument, ChattyContentSticker, ChattyContentCentral]
+

letschatty/models/messages/chatty_messages/schema/chatty_content/content_audio.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+class ChattyContentAudio(BaseModel):
+    url: str = Field(description="URL of the media from S3")
+    mime_type: str
+    sha256: str

letschatty/models/messages/chatty_messages/schema/chatty_content/content_central.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+# Soolo se generan DESDE LA BASE DE DATOS
+class ChattyContentCentral(BaseModel):
+    body: str

letschatty/models/messages/chatty_messages/schema/chatty_content/content_contacts.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+
+class ChattyContentContacts(BaseModel):
+    full_name: str #Meta Formatted name
+    phone_number: str #Meta waid
+    name_details: Optional[Dict[str, Any]] = None
+    phones: Optional[List[Dict[str, Any]]] = None
+    addresses: Optional[List[Dict[str, Any]]] = None
+    birthday: Optional[str] = None
+    emails: Optional[List[Dict[str, Any]]] = None
+    org: Optional[Dict[str, Any]] = None
+    urls: Optional[List[Dict[str, Any]]] = None
+    
+    def model_dump(self) -> Dict[str, Any]:
+        data = super().model_dump(exclude_none=True)
+        return data
+        
+        
+        
+

letschatty/models/messages/chatty_messages/schema/chatty_content/content_document.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+from .content_media import ChattyContentMedia
+
+class ChattyContentDocument(ChattyContentMedia):
+    filename: str = Field(description="Name of the document")
+
+
+    

letschatty/models/messages/chatty_messages/schema/chatty_content/content_image.py

@@ -0,0 +1,4 @@
+from .content_media import ChattyContentMedia
+
+class ChattyContentImage(ChattyContentMedia):
+    pass

letschatty/models/messages/chatty_messages/schema/chatty_content/content_location.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class ChattyContentLocation(BaseModel):
+    latitude: float
+    longitude: float

letschatty/models/messages/chatty_messages/schema/chatty_content/content_media.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+class ChattyContentMedia(BaseModel):
+    id: Optional[str] = Field(description="Unique identifier for the image. Also known as media_id")
+    url: str = Field(description="URL of the media from S3")
+    caption: str = Field(default="", description="Caption of the media that goes as a text below the media")
+    mime_type: str
+    sha256: str

letschatty/models/messages/chatty_messages/schema/chatty_content/content_reaction.py

@@ -0,0 +1,4 @@
+from pydantic import BaseModel
+
+class ChattyContentReaction(BaseModel):
+    emoji: str

letschatty/models/messages/chatty_messages/schema/chatty_content/content_sticker.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+class ChattyContentSticker(BaseModel):
+    url: str = Field(description="URL of the media from S3")
+    mime_type: str
+    sha256: str

letschatty/models/messages/chatty_messages/schema/chatty_content/content_text.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class ChattyContentText(BaseModel):
+    body: str 
+    preview_url: bool = False

letschatty/models/messages/chatty_messages/schema/chatty_content/content_video.py

@@ -0,0 +1,5 @@
+from .content_media import ChattyContentMedia
+
+class ChattyContentVideo(ChattyContentMedia):
+    pass
+

letschatty/models/messages/chatty_messages/schema/chatty_context/chatty_context.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from pydantic import BaseModel
+from typing import Optional
+
+from ....meta_message_model.meta_message_json import MetaContext
+    
+class ChattyContext(BaseModel):
+    message_id: str
+    template_name: Optional[str] = None
+    response_id: Optional[str] = None
+    
+    def model_dump(self, *args, **kwargs):
+        kwargs['exclude_unset'] = True
+        return super().model_dump(*args, **kwargs)
+    
+    @classmethod
+    def from_meta(cls, meta_context: MetaContext) -> ChattyContext:
+        return cls(message_id=meta_context.id)
+
+    @classmethod
+    def default(cls) -> ChattyContext:
+        return cls(message_id="")

letschatty/models/messages/chatty_messages/schema/chatty_referal/chatty_referal.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from ....meta_message_model.meta_message_json import MetaReferral
+
+class ChattyReferral(BaseModel):
+    source_url: str
+    source_id: str
+    source_type: str
+    headline: Optional[str] = None
+    body: Optional[str] = None
+    media_type: Optional[str] = None
+    image_url: Optional[str] = None
+    video_url: Optional[str] = None
+    thumbnail_url: Optional[str] = None
+    ctwa_clid: Optional[str] = None
+
+    @property
+    def is_default(self) -> bool:
+        return self.source_url == "" and self.source_id == "" and self.source_type == ""
+    
+    @classmethod
+    def from_meta(cls, meta_referral: MetaReferral) -> ChattyReferral:
+        if meta_referral.context is None:
+            return cls.default()
+        return cls(**meta_referral.model_dump())
+
+    @classmethod
+    def default(cls) -> ChattyReferral:
+        return cls(
+            source_url="",
+            source_id="",
+            source_type=""
+        )

letschatty/models/messages/chatty_messages/sticker.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentSticker
+
+class StickerMessage(Message):
+    type: MessageType = MessageType.STICKER
+    content: ChattyContentSticker

letschatty/models/messages/chatty_messages/text.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentText
+
+class TextMessage(Message):
+    type: MessageType = MessageType.TEXT
+    content: ChattyContentText

letschatty/models/messages/chatty_messages/unknown.py

@@ -0,0 +1,6 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+
+class UnknownMessage(Message):
+    #TODO: Implementar
+    type: str = MessageType.UNSUPPORTED

letschatty/models/messages/chatty_messages/unsupported.py

@@ -0,0 +1,5 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+
+class UnsupportedMessage(Message):
+    type: str = MessageType.UNSUPPORTED

letschatty/models/messages/chatty_messages/video.py

@@ -0,0 +1,7 @@
+from .base.message_base import Message
+from ...utils.types.message_types import MessageType
+from .schema import ChattyContentVideo
+
+class VideoMessage(Message):
+    type: MessageType = MessageType.VIDEO
+    content: ChattyContentVideo

letschatty/models/messages/messages_request/__init__.py

@@ -0,0 +1 @@
+from .message_request import MessageRequest