unstructured-ingest 0.0.0__py3-none-any.whl

unstructured_ingest/connector/notion/types/database_properties/rollup.py

@@ -0,0 +1,56 @@
+# https://developers.notion.com/reference/property-object#rollup
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag, Span
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class RollupProp(FromJSONMixin):
+    function: str
+    relation_property_id: str
+    relation_property_name: str
+    rollup_property_id: str
+    rollup_property_name: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class Rollup(DBPropertyBase):
+    id: str
+    name: str
+    rollup: RollupProp
+    type: str = "rollup"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(rollup=RollupProp.from_dict(data.pop("rollup")), **data)
+
+
+@dataclass
+class RollupCell(DBCellBase):
+    id: str
+    rollup: dict
+    type: str = "rollup"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        rollup = self.rollup
+        t = rollup.get("type")
+        v = rollup[t]
+        if isinstance(v, list):
+            return Div([], [Span([], str(x)) for x in v])
+        return Div([], str(v))

unstructured_ingest/connector/notion/types/database_properties/select.py

@@ -0,0 +1,68 @@
+# https://developers.notion.com/reference/property-object#select
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from htmlBuilder.attributes import Style
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class SelectOption(FromJSONMixin):
+    color: str
+    id: str
+    name: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class SelectProp(FromJSONMixin):
+    options: List[SelectOption] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(options=[SelectOption.from_dict(o) for o in data.get("options", [])])
+
+
+@dataclass
+class Select(DBPropertyBase):
+    id: str
+    name: str
+    select: SelectProp
+    type: str = "select"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(select=SelectProp.from_dict(data.pop("select", {})), **data)
+
+
+@dataclass
+class SelectCell(DBCellBase):
+    id: str
+    select: Optional[SelectOption]
+    type: str = "select"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        select_data = data.pop("select")
+        select = None
+        if select_data:
+            select = SelectOption.from_dict(select_data)
+        return cls(select=select, **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if select := self.select:
+            select_attr = []
+            if select.color and select.color != "default":
+                select_attr.append(Style(f"color: {select.color}"))
+            return Div(select_attr, select.name)
+        return None

unstructured_ingest/connector/notion/types/database_properties/status.py

@@ -0,0 +1,80 @@
+# https://developers.notion.com/reference/property-object#status
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from htmlBuilder.attributes import Style
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class StatusOption(FromJSONMixin):
+    color: str
+    id: str
+    name: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class StatusGroup(FromJSONMixin):
+    color: str
+    id: str
+    name: str
+    option_ids: List[str] = field(default_factory=List[str])
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class StatusProp(FromJSONMixin):
+    options: List[StatusOption] = field(default_factory=list)
+    groups: List[StatusGroup] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            options=[StatusOption.from_dict(o) for o in data.get("options", [])],
+            groups=[StatusGroup.from_dict(g) for g in data.get("groups", [])],
+        )
+
+
+@dataclass
+class Status(DBPropertyBase):
+    id: str
+    name: str
+    status: StatusProp
+    type: str = "status"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(status=StatusProp.from_dict(data.pop("status", {})), **data)
+
+
+@dataclass
+class StatusCell(DBCellBase):
+    id: str
+    status: Optional[StatusOption]
+    type: str = "status"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(status=StatusOption.from_dict(data.pop("status", {})), **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if status := self.status:
+            select_attr = []
+            if status.color and status.color != "default":
+                select_attr.append(Style(f"color: {status.color}"))
+            return Div(select_attr, status.name)
+        return None

unstructured_ingest/connector/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/connector/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/connector/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/connector/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/connector/notion/types/date.py

@@ -0,0 +1,26 @@
+# 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.connector.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/connector/notion/types/file.py

@@ -0,0 +1,51 @@
+# 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.connector.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/connector/notion/types/page.py

@@ -0,0 +1,44 @@
+# https://developers.notion.com/reference/page
+from dataclasses import dataclass
+from typing import Optional
+
+from unstructured_ingest.connector.notion.interfaces import FromJSONMixin
+from unstructured_ingest.connector.notion.types.file import FileObject
+from unstructured_ingest.connector.notion.types.parent import Parent
+from unstructured_ingest.connector.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
+    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/connector/notion/types/parent.py

@@ -0,0 +1,66 @@
+# https://developers.notion.com/reference/parent-object
+from dataclasses import dataclass
+
+from unstructured_ingest.connector.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)