unstructured-ingest 1.2.32__py3-none-any.whl

unstructured_ingest/processes/connectors/notion/types/database_properties/people.py

@@ -0,0 +1,42 @@
+# https://developers.notion.com/reference/property-object#people
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from htmlBuilder.tags import Div, HtmlTag, Span
+
+from unstructured_ingest.processes.connectors.notion.interfaces import DBCellBase, DBPropertyBase
+from unstructured_ingest.processes.connectors.notion.types.user import People as PeopleType
+
+
+@dataclass
+class People(DBPropertyBase):
+    id: str
+    name: str
+    description: Optional[str] = None
+    type: str = "people"
+    description: Optional[str] = None
+    people: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class PeopleCell(DBCellBase):
+    id: str
+    people: List[PeopleType]
+    type: str = "people"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(people=[PeopleType.from_dict(p) for p in data.pop("people", {})], **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if not self.people:
+            return None
+        people_spans = []
+        for person in self.people:
+            people_spans.append(Span([], person.get_html()))
+        return Div([], people_spans)

unstructured_ingest/processes/connectors/notion/types/database_properties/phone_number.py

@@ -0,0 +1,37 @@
+# https://developers.notion.com/reference/property-object#phone-number
+from dataclasses import dataclass, field
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.processes.connectors.notion.interfaces import DBCellBase, DBPropertyBase
+
+
+@dataclass
+class PhoneNumber(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "phone_number"
+    description: Optional[str] = None
+    phone_number: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class PhoneNumberCell(DBCellBase):
+    id: str
+    phone_number: Optional[str]
+    name: Optional[str] = None
+    type: str = "phone_number"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if phone_number := self.phone_number:
+            return Div([], phone_number)
+        return None

unstructured_ingest/processes/connectors/notion/types/database_properties/relation.py

@@ -0,0 +1,68 @@
+# https://developers.notion.com/reference/property-object#relation
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import unquote
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.processes.connectors.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class DualProperty(FromJSONMixin):
+    synced_property_id: str
+    synced_property_name: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class RelationProp(FromJSONMixin):
+    database_id: str
+    type: str
+    dual_property: DualProperty
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        t = data.get("type")
+        if t == "dual_property":
+            dual_property = DualProperty.from_dict(data.pop(t))
+        else:
+            raise ValueError(f"{t} type not recognized")
+
+        return cls(dual_property=dual_property, **data)
+
+
+@dataclass
+class Relation(DBPropertyBase):
+    id: str
+    name: str
+    relation: RelationProp
+    type: str = "relation"
+    description: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(relation=RelationProp.from_dict(data.pop("relation")), **data)
+
+
+@dataclass
+class RelationCell(DBCellBase):
+    id: str
+    has_more: bool
+    relation: list
+    type: str = "relation"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return Div([], unquote(self.id))

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

@@ -0,0 +1,44 @@
+# 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.processes.connectors.notion.interfaces import DBCellBase, DBPropertyBase
+from unstructured_ingest.processes.connectors.notion.types.rich_text import (
+    RichText as RichTextType,
+)
+
+
+@dataclass
+class RichText(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "rich_text"
+    description: Optional[str] = None
+    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/processes/connectors/notion/types/database_properties/rollup.py

@@ -0,0 +1,57 @@
+# 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.processes.connectors.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"
+    description: Optional[str] = None
+
+    @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/processes/connectors/notion/types/database_properties/select.py

@@ -0,0 +1,70 @@
+# 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.processes.connectors.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class SelectOption(FromJSONMixin):
+    color: str
+    id: str
+    name: str
+    description: Optional[str] = None
+
+    @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"
+    description: Optional[str] = None
+
+    @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/processes/connectors/notion/types/database_properties/status.py

@@ -0,0 +1,82 @@
+# 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.processes.connectors.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class StatusOption(FromJSONMixin):
+    color: str
+    id: str
+    name: str
+    description: Optional[str] = None
+
+    @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"
+    description: Optional[str] = None
+
+    @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/processes/connectors/notion/types/database_properties/title.py

@@ -0,0 +1,38 @@
+# 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.processes.connectors.notion.interfaces import DBCellBase, DBPropertyBase
+from unstructured_ingest.processes.connectors.notion.types.rich_text import RichText
+
+
+@dataclass
+class Title(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "title"
+    title: dict = field(default_factory=dict)
+    description: Optional[str] = None
+
+    @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/processes/connectors/notion/types/database_properties/unique_id.py

@@ -0,0 +1,51 @@
+# 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.processes.connectors.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)
+    description: Optional[str] = None
+
+    @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/processes/connectors/notion/types/database_properties/url.py

@@ -0,0 +1,38 @@
+# 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.processes.connectors.notion.interfaces import DBCellBase, DBPropertyBase
+
+
+@dataclass
+class URL(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "url"
+    url: dict = field(default_factory=dict)
+    description: Optional[str] = None
+
+    @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/processes/connectors/notion/types/database_properties/verification.py

@@ -0,0 +1,79 @@
+# 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.processes.connectors.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+    GetHTMLMixin,
+)
+from unstructured_ingest.processes.connectors.notion.types.date import Date
+from unstructured_ingest.processes.connectors.notion.types.user import People
+
+
+@dataclass
+class Verification(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "verification"
+    verification: dict = field(default_factory=dict)
+    description: Optional[str] = None
+
+    @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/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.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/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.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