unstructured-ingest 1.2.32__py3-none-any.whl

unstructured_ingest/processes/connectors/notion/types/page.py

@@ -0,0 +1,52 @@
+# https://developers.notion.com/reference/page
+from dataclasses import dataclass, fields
+from typing import Optional
+
+from unstructured_ingest.processes.connectors.notion.interfaces import FromJSONMixin
+from unstructured_ingest.processes.connectors.notion.types.file import FileObject
+from unstructured_ingest.processes.connectors.notion.types.parent import Parent
+from unstructured_ingest.processes.connectors.notion.types.user import PartialUser
+
+
+@dataclass
+class Page(FromJSONMixin):
+    id: str
+    created_time: str
+    created_by: PartialUser
+    last_edited_time: str
+    last_edited_by: PartialUser
+    archived: bool
+    in_trash: bool
+    properties: dict
+    parent: Parent
+    url: str
+    public_url: str
+    request_id: Optional[str] = None
+    object: str = "page"
+    icon: Optional[FileObject] = None
+    cover: Optional[FileObject] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()  # Don't modify the original
+        created_by = data.pop("created_by")
+        last_edited_by = data.pop("last_edited_by")
+        icon = data.pop("icon")
+        cover = data.pop("cover")
+        parent = data.pop("parent")
+
+        # Filter data to only include fields that exist in the dataclass
+        filtered_data = {
+            k: v for k, v in data.items() if k in {field.name for field in fields(cls)}
+        }
+
+        page = cls(
+            created_by=PartialUser.from_dict(created_by),
+            last_edited_by=PartialUser.from_dict(last_edited_by),
+            icon=FileObject.from_dict(icon) if icon else None,
+            cover=FileObject.from_dict(cover) if cover else None,
+            parent=Parent.from_dict(parent),
+            **filtered_data,
+        )
+
+        return page

unstructured_ingest/processes/connectors/notion/types/parent.py

@@ -0,0 +1,66 @@
+# https://developers.notion.com/reference/parent-object
+from dataclasses import dataclass
+
+from unstructured_ingest.processes.connectors.notion.interfaces import FromJSONMixin
+
+
+# https://developers.notion.com/reference/parent-object#database-parent
+@dataclass
+class DatabaseParent(FromJSONMixin):
+    database_id: str
+    type: str = "database_id"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(database_id=data["database_id"])
+
+
+# https://developers.notion.com/reference/parent-object#page-parent
+@dataclass
+class PageParent(FromJSONMixin):
+    page_id: str
+    type: str = "page_id"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(page_id=data["page_id"])
+
+
+# https://developers.notion.com/reference/parent-object#workspace-parent
+@dataclass
+class WorkspaceParent(FromJSONMixin):
+    type: str = "workspace"
+    workspace: bool = True
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls()
+
+
+# https://developers.notion.com/reference/parent-object#block-parent
+@dataclass
+class BlockParent(FromJSONMixin):
+    block_id: str
+    type: str = "block_id"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(block_id=data["block_id"])
+
+
+@dataclass
+class Parent(FromJSONMixin):
+    block_id: str
+    type: str = "block_id"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        t = data["type"]
+        if t == "database_id":
+            return DatabaseParent.from_dict(data)
+        elif t == "page_id":
+            return PageParent.from_dict(data)
+        elif t == "workspace":
+            return WorkspaceParent.from_dict(data)
+        elif t == "block_id":
+            return BlockParent.from_dict(data)

unstructured_ingest/processes/connectors/notion/types/rich_text.py

@@ -0,0 +1,189 @@
+# https://developers.notion.com/reference/rich-text
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.attributes import Href, Style
+from htmlBuilder.tags import A, B, Code, Div, HtmlTag, I, S, Span, U
+from htmlBuilder.tags import Text as HtmlText
+
+from unstructured_ingest.processes.connectors.notion.interfaces import (
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+from unstructured_ingest.processes.connectors.notion.types.date import Date
+from unstructured_ingest.processes.connectors.notion.types.user import People
+
+
+@dataclass
+class Annotations(FromJSONMixin):
+    bold: bool
+    code: bool
+    italic: bool
+    strikethrough: bool
+    underline: bool
+    color: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class Equation(FromJSONMixin, GetHTMLMixin):
+    expression: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return Code([], self.expression) if self.expression else None
+
+
+@dataclass
+class MentionDatabase(FromJSONMixin, GetHTMLMixin):
+    id: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return Div([], self.id) if self.id else None
+
+
+@dataclass
+class MentionLinkPreview(FromJSONMixin, GetHTMLMixin):
+    url: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return A([Href(self.url)], self.url) if self.url else None
+
+
+@dataclass
+class MentionPage(FromJSONMixin, GetHTMLMixin):
+    id: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return Div([], self.id) if self.id else None
+
+
+@dataclass
+class MentionTemplate(FromJSONMixin):
+    template_mention_date: Optional[str]
+    template_mention_user: Optional[str]
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class Mention(FromJSONMixin, GetHTMLMixin):
+    type: str
+    database: Optional[MentionDatabase] = None
+    date: Optional[Date] = None
+    link_preview: Optional[MentionLinkPreview] = None
+    page: Optional[MentionPage] = None
+    template_mention: Optional[MentionTemplate] = None
+    user: Optional[People] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        t = data["type"]
+        mention = cls(type=t)
+        if t == "date":
+            mention.date = Date.from_dict(data["date"])
+        elif t == "database":
+            mention.database = MentionDatabase.from_dict(data["database"])
+        elif t == "link_preview":
+            mention.link_preview = MentionLinkPreview.from_dict(data["link_preview"])
+        elif t == "page":
+            mention.page = MentionPage.from_dict(data["page"])
+        elif t == "template_mention":
+            mention.template_mention = MentionTemplate.from_dict(data["template_mention"])
+        elif t == "user":
+            mention.user = People.from_dict(data["user"])
+
+        return mention
+
+    def get_html(self) -> Optional[HtmlTag]:
+        t = self.type
+        if t == "date":
+            return self.date.get_html() if self.date else None
+        elif t == "database":
+            return self.database.get_html() if self.database else None
+        elif t == "link_preview":
+            return self.link_preview.get_html() if self.link_preview else None
+        elif t == "page":
+            return self.page.get_html() if self.page else None
+        elif t == "user":
+            return self.user.get_html() if self.user else None
+        return None
+
+
+@dataclass
+class Text(FromJSONMixin):
+    content: str
+    link: Optional[dict]
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class RichText(FromJSONMixin, GetHTMLMixin):
+    type: str
+    plain_text: str
+    annotations: Optional[Annotations] = None
+    href: Optional[str] = None
+    text: Optional[Text] = None
+    mention: Optional[Mention] = None
+    equation: Optional[Equation] = None
+
+    def get_html(self) -> Optional[HtmlTag]:
+        text = HtmlText(self.plain_text)
+        if self.href:
+            text = A([Href(self.href)], text)
+        if self.annotations:
+            annotations = self.annotations
+            if annotations.bold:
+                text = B([], text)
+            if annotations.code:
+                text = Code([], text)
+            if annotations.italic:
+                text = I([], text)
+            if annotations.strikethrough:
+                text = S([], text)
+            if annotations.underline:
+                text = U([], text)
+            if annotations.color and annotations.color != "default":
+                if isinstance(text, HtmlText):
+                    text = Span([], text)
+                text.attributes.append(Style(f"color:{annotations.color}"))
+        return text
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        t = data["type"]
+        rich_text = cls(
+            annotations=Annotations.from_dict(data.pop("annotations")),
+            **data,
+        )
+        if t == "text":
+            rich_text.text = Text.from_dict(data["text"])
+        elif t == "mention":
+            rich_text.mention = Mention.from_dict(data["mention"])
+        elif t == "equation":
+            rich_text.equation = Equation.from_dict(data["equation"])
+
+        return rich_text

unstructured_ingest/processes/connectors/notion/types/user.py

@@ -0,0 +1,83 @@
+# https://developers.notion.com/reference/user
+from dataclasses import dataclass, field
+from typing import Optional
+
+from htmlBuilder.attributes import Href
+from htmlBuilder.tags import A, Div, HtmlTag
+
+from unstructured_ingest.processes.connectors.notion.interfaces import (
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+
+
+@dataclass
+class PartialUser(FromJSONMixin):
+    id: str
+    object: str = "user"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(id=data["id"])
+
+
+@dataclass
+class User(FromJSONMixin, GetHTMLMixin):
+    object: dict
+    id: str
+    type: Optional[str] = None
+    name: Optional[str] = None
+    avatar_url: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_text(self) -> Optional[str]:
+        text = self.name
+        if self.avatar_url:
+            text = f"[{text}]({self.avatar_url})"
+        return text
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if self.avatar_url and self.name:
+            return A([Href(self.avatar_url)], self.name)
+        elif self.name:
+            return Div([], self.name)
+        else:
+            return Div([], "")
+
+
+@dataclass
+class People(User):
+    person: dict = field(default_factory=dict)
+
+
+@dataclass
+class Bots(FromJSONMixin, GetHTMLMixin):
+    object: dict
+    id: str
+    bot: dict
+    owner: dict
+    type: str
+    workspace_name: str
+    name: Optional[str] = None
+    avatar_url: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_text(self) -> Optional[str]:
+        text = self.name
+        if self.avatar_url:
+            text = f"[{text}]({self.avatar_url})"
+        return text
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if self.avatar_url and self.name:
+            return A([Href(self.avatar_url)], self.name)
+        elif self.name:
+            return Div([], self.name)
+        else:
+            return Div([], "")