unstructured-ingest 0.3.13__py3-none-any.whl

unstructured_ingest/v2/processes/connectors/notion/types/database_properties/title.py

@@ -0,0 +1,37 @@
+# https://developers.notion.com/reference/property-object#title
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
+from unstructured_ingest.connector.notion.types.rich_text import RichText
+
+
+@dataclass
+class Title(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "title"
+    title: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class TitleCell(DBCellBase):
+    id: str
+    title: List[RichText]
+    type: str = "title"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(title=[RichText.from_dict(rt) for rt in data.pop("title", [])], **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if not self.title:
+            return None
+        return Div([], [rt.get_html() for rt in self.title])

unstructured_ingest/v2/processes/connectors/notion/types/database_properties/unique_id.py

@@ -0,0 +1,50 @@
+# https://developers.notion.com/reference/property-object#title
+from dataclasses import dataclass, field
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class UniqueID(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "unique_id"
+    unique_id: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class UniqueIDCellData(FromJSONMixin):
+    prefix: str
+    number: int
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class UniqueIDCell(DBCellBase):
+    id: str
+    unique_id: Optional[UniqueIDCellData]
+    type: str = "title"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(unique_id=UniqueIDCellData.from_dict(data.pop("unique_id")), **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if unique_id := self.unique_id:
+            return Div([], f"{unique_id.prefix}-{unique_id.number}")
+        return None

unstructured_ingest/v2/processes/connectors/notion/types/database_properties/url.py

@@ -0,0 +1,37 @@
+# https://developers.notion.com/reference/property-object#url
+from dataclasses import dataclass, field
+from typing import Optional
+
+from htmlBuilder.attributes import Href
+from htmlBuilder.tags import A, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
+
+
+@dataclass
+class URL(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "url"
+    url: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class URLCell(DBCellBase):
+    id: str
+    url: Optional[str] = None
+    name: Optional[str] = None
+    type: str = "url"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if url := self.url:
+            return A([Href(url)], url)
+        return None

unstructured_ingest/v2/processes/connectors/notion/types/database_properties/verification.py

@@ -0,0 +1,78 @@
+# https://developers.notion.com/reference/property-object#url
+from dataclasses import dataclass, field
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag, Span
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+from unstructured_ingest.connector.notion.types.date import Date
+from unstructured_ingest.connector.notion.types.user import People
+
+
+@dataclass
+class Verification(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "verification"
+    verification: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class VerificationData(FromJSONMixin, GetHTMLMixin):
+    state: Optional[str]
+    verified_by: Optional[People]
+    date: Optional[Date]
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        verified_by = data.pop("verified_by", None)
+        date = data.pop("date", None)
+        return cls(
+            verified_by=People.from_dict(data=verified_by) if verified_by else None,
+            date=Date.from_dict(data=date) if date else None,
+            **data,
+        )
+
+    def get_html(self) -> Optional[HtmlTag]:
+        elements = []
+        if state := self.state:
+            elements.append(Span([], state))
+        if (verified_by := self.verified_by) and (verified_by_html := verified_by.get_html()):
+            elements.append(verified_by_html)
+        if (date := self.date) and (date_html := date.get_html()):
+            elements.append(date_html)
+        if elements:
+            return Div([], elements)
+        return None
+
+
+@dataclass
+class VerificationCell(DBCellBase):
+    id: str
+    verification: Optional[VerificationData]
+    name: Optional[str] = None
+    type: str = "verification"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(verification=VerificationData.from_dict(data.pop("verification")), **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        elements = []
+        if name := self.name:
+            elements.append(Span([], name))
+        if (verification := self.verification) and (verification_html := verification.get_html()):
+            elements.append(verification_html)
+
+        if elements:
+            return Div([], elements)
+        return None

unstructured_ingest/v2/processes/connectors/notion/types/date.py

@@ -0,0 +1,29 @@
+# https://developers.notion.com/reference/property-value-object#date-property-values
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.v2.processes.connectors.notion.interfaces import (
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+
+
+@dataclass
+class Date(FromJSONMixin, GetHTMLMixin):
+    start: str
+    end: Optional[str] = None
+    time_zone: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        text = f"{self.start}"
+        if end := self.end:
+            text += f" - {end}"
+        if self.time_zone:
+            text += f" {self.time_zone}"
+        return Div([], text)

unstructured_ingest/v2/processes/connectors/notion/types/file.py

@@ -0,0 +1,54 @@
+# https://developers.notion.com/reference/file-object
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.attributes import Href
+from htmlBuilder.tags import A, HtmlTag
+
+from unstructured_ingest.v2.processes.connectors.notion.interfaces import (
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+
+
+@dataclass
+class External(FromJSONMixin):
+    url: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class File(FromJSONMixin):
+    url: str
+    expiry_time: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class FileObject(FromJSONMixin, GetHTMLMixin):
+    type: str
+    external: Optional[External] = None
+    file: Optional[File] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        t = data["type"]
+        file_object = cls(type=t)
+        if t == "external":
+            file_object.external = External.from_dict(data["external"])
+        elif t == "file":
+            file_object.file = File.from_dict(data["file"])
+        return file_object
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if self.file:
+            return A([Href(self.file.url)], self.file.url)
+        if self.external:
+            return A([Href(self.external.url)], self.external.url)
+        return None

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

@@ -0,0 +1,45 @@
+# https://developers.notion.com/reference/page
+from dataclasses import dataclass
+from typing import Optional
+
+from unstructured_ingest.v2.processes.connectors.notion.interfaces import FromJSONMixin
+from unstructured_ingest.v2.processes.connectors.notion.types.file import FileObject
+from unstructured_ingest.v2.processes.connectors.notion.types.parent import Parent
+from unstructured_ingest.v2.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):
+        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")
+        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),
+            **data,
+        )
+
+        return page

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

@@ -0,0 +1,66 @@
+# https://developers.notion.com/reference/parent-object
+from dataclasses import dataclass
+
+from unstructured_ingest.v2.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/v2/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.v2.processes.connectors.notion.interfaces import (
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+from unstructured_ingest.v2.processes.connectors.notion.types.date import Date
+from unstructured_ingest.v2.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/v2/processes/connectors/notion/types/user.py

@@ -0,0 +1,79 @@
+# 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.v2.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:
+            return A([Href(self.avatar_url)], self.name)
+        else:
+            return Div([], self.name)
+
+
+@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:
+            return A([Href(self.avatar_url)], self.name)
+        else:
+            return Div([], self.name)