unstructured-ingest 0.3.13__py3-none-any.whl

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

@@ -0,0 +1,37 @@
+# https://developers.notion.com/reference/property-object#files
+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.file import FileObject
+
+
+@dataclass
+class Files(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "files"
+    files: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class FilesCell(DBCellBase):
+    id: str
+    files: List[FileObject]
+    type: str = "files"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(files=[FileObject.from_dict(f) for f in data.pop("files", [])], **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if not self.files:
+            return None
+        return Div([], [f.get_html() for f in self.files])

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

@@ -0,0 +1,49 @@
+# https://developers.notion.com/reference/property-object#formula
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class FormulaProp(FromJSONMixin):
+    expression: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class Formula(DBPropertyBase):
+    id: str
+    name: str
+    formula: FormulaProp
+    type: str = "formula"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(formula=FormulaProp.from_dict(data.pop("formula", {})), **data)
+
+
+@dataclass
+class FormulaCell(DBCellBase):
+    id: str
+    formula: dict
+    type: str = "formula"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        formula = self.formula
+        t = formula.get("type")
+        return Div([], str(formula[t]))

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

@@ -0,0 +1,34 @@
+# https://developers.notion.com/reference/property-object#last-edited-by
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.tags import HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
+from unstructured_ingest.connector.notion.types.user import People
+
+
+@dataclass
+class LastEditedBy(DBPropertyBase):
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls()
+
+    def get_text(self) -> Optional[str]:
+        return None
+
+
+@dataclass
+class LastEditedByCell(DBCellBase):
+    id: str
+    last_edited_by: People
+    type: str = "last_edited_by"
+
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(last_edited_by=People.from_dict(data.pop("last_edited_by", {})), **data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return self.last_edited_by.get_html()

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

@@ -0,0 +1,34 @@
+# https://developers.notion.com/reference/property-object#last-edited-time
+from dataclasses import dataclass, field
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
+
+
+@dataclass
+class LastEditedTime(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "last_edited_time"
+    last_edited_time: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class LastEditedTimeCell(DBCellBase):
+    id: str
+    last_edited_time: str
+    type: str = "last_edited_time"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        return Div([], self.last_edited_time)

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

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

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

@@ -0,0 +1,49 @@
+# https://developers.notion.com/reference/property-object#number
+from dataclasses import dataclass
+from typing import Optional
+
+from htmlBuilder.tags import Div, HtmlTag
+
+from unstructured_ingest.connector.notion.interfaces import (
+    DBCellBase,
+    DBPropertyBase,
+    FromJSONMixin,
+)
+
+
+@dataclass
+class NumberProp(FromJSONMixin):
+    format: str
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+
+@dataclass
+class Number(DBPropertyBase):
+    id: str
+    name: str
+    number: NumberProp
+    type: str = "number"
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(number=NumberProp.from_dict(data.pop("number")), **data)
+
+
+@dataclass
+class NumberCell(DBCellBase):
+    id: str
+    number: Optional[int] = None
+    type: str = "number"
+    name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**data)
+
+    def get_html(self) -> Optional[HtmlTag]:
+        if number := self.number:
+            return Div([], str(number))
+        return None

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

@@ -0,0 +1,41 @@
+# 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.connector.notion.interfaces import DBCellBase, DBPropertyBase
+from unstructured_ingest.connector.notion.types.user import People as PeopleType
+
+
+@dataclass
+class People(DBPropertyBase):
+    id: str
+    name: str
+    description: Optional[str] = None
+    type: str = "people"
+    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/v2/processes/connectors/notion/types/database_properties/phone_number.py

@@ -0,0 +1,36 @@
+# 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.connector.notion.interfaces import DBCellBase, DBPropertyBase
+
+
+@dataclass
+class PhoneNumber(DBPropertyBase):
+    id: str
+    name: str
+    type: str = "phone_number"
+    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/v2/processes/connectors/notion/types/database_properties/relation.py

@@ -0,0 +1,67 @@
+# 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.connector.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"
+
+    @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/v2/processes/connectors/notion/types/database_properties/rich_text.py

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

@@ -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/v2/processes/connectors/notion/types/database_properties/select.py

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

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