unstructured-ingest 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

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

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

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

@@ -1,56 +0,0 @@
-# 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/v2/processes/connectors/notion/types/database_properties/title.py

@@ -1,37 +0,0 @@
-# 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/url.py

@@ -1,37 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-# 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/page.py

@@ -1,45 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-# 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

@@ -1,189 +0,0 @@
-# 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