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

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

@@ -1,106 +0,0 @@
-from typing import Dict
-
-from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
-
-from .checkbox import Checkbox, CheckboxCell
-from .created_by import CreatedBy, CreatedByCell
-from .created_time import CreatedTime, CreatedTimeCell
-from .date import Date, DateCell
-from .email import Email, EmailCell
-from .files import Files, FilesCell
-from .formula import Formula, FormulaCell
-from .last_edited_by import LastEditedBy, LastEditedByCell
-from .last_edited_time import LastEditedTime, LastEditedTimeCell
-from .multiselect import MultiSelect, MultiSelectCell
-from .number import Number, NumberCell
-from .people import People, PeopleCell
-from .phone_number import PhoneNumber, PhoneNumberCell
-from .relation import Relation, RelationCell
-from .rich_text import RichText, RichTextCell
-from .rollup import Rollup, RollupCell
-from .select import Select, SelectCell
-from .status import Status, StatusCell
-from .title import Title, TitleCell
-from .unique_id import UniqueID, UniqueIDCell
-from .url import URL, URLCell
-from .verification import Verification, VerificationCell
-
-db_prop_type_mapping = {
-    "checkbox": Checkbox,
-    "created_by": CreatedBy,
-    "created_time": CreatedTime,
-    "date": Date,
-    "email": Email,
-    "files": Files,
-    "formula": Formula,
-    "last_edited_by": LastEditedBy,
-    "last_edited_time": LastEditedTime,
-    "multi_select": MultiSelect,
-    "number": Number,
-    "people": People,
-    "phone_number": PhoneNumber,
-    "relation": Relation,
-    "rich_text": RichText,
-    "rollup": Rollup,
-    "select": Select,
-    "status": Status,
-    "title": Title,
-    "unique_id": UniqueID,
-    "url": URL,
-    "verification": Verification,
-}
-
-
-def map_properties(props: Dict[str, dict]) -> Dict[str, DBPropertyBase]:
-    mapped_dict = {}
-    for k, v in props.items():
-        try:
-            mapped_dict[k] = db_prop_type_mapping[v["type"]].from_dict(v)  # type: ignore
-        except KeyError as ke:
-            raise KeyError(f"failed to map to associated database property -> {k}: {v}") from ke
-
-    return mapped_dict
-
-
-db_cell_type_mapping = {
-    "checkbox": CheckboxCell,
-    "created_by": CreatedByCell,
-    "created_time": CreatedTimeCell,
-    "date": DateCell,
-    "email": EmailCell,
-    "files": FilesCell,
-    "formula": FormulaCell,
-    "last_edited_by": LastEditedByCell,
-    "last_edited_time": LastEditedTimeCell,
-    "multi_select": MultiSelectCell,
-    "number": NumberCell,
-    "people": PeopleCell,
-    "phone_number": PhoneNumberCell,
-    "relation": RelationCell,
-    "rich_text": RichTextCell,
-    "rollup": RollupCell,
-    "select": SelectCell,
-    "status": StatusCell,
-    "title": TitleCell,
-    "unique_id": UniqueIDCell,
-    "url": URLCell,
-    "verification": VerificationCell,
-}
-
-
-def map_cells(props: Dict[str, dict]) -> Dict[str, DBCellBase]:
-    mapped_dict = {}
-    for k, v in props.items():
-        try:
-            t = v["type"]
-            mapped_dict[k] = db_cell_type_mapping[t].from_dict(v)  # type: ignore
-        except KeyError as ke:
-            raise KeyError(f"failed to map to associated database property -> {k}: {v}") from ke
-
-    return mapped_dict
-
-
-__all__ = [
-    "map_properties",
-    "map_cells",
-]

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

@@ -1,38 +0,0 @@
-# https://developers.notion.com/reference/property-object#checkbox
-from dataclasses import dataclass, field
-from typing import Optional
-
-from htmlBuilder.attributes import Checked, Type
-from htmlBuilder.tags import Div, HtmlTag, Input
-
-from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
-
-
-@dataclass
-class Checkbox(DBPropertyBase):
-    id: str
-    name: str
-    type: str = "checkbox"
-    checkbox: dict = field(default_factory=dict)
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        return cls(**data)
-
-
-@dataclass
-class CheckboxCell(DBCellBase):
-    id: str
-    checkbox: bool
-    name: Optional[str] = None
-    type: str = "checkbox"
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        return cls(**data)
-
-    def get_html(self) -> Optional[HtmlTag]:
-        check_input_attributes = [Type("checkbox")]
-        if self.checkbox:
-            check_input_attributes.append(Checked(""))
-        return Div([], Input(check_input_attributes))

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

@@ -1,41 +0,0 @@
-# https://developers.notion.com/reference/property-object#date
-from dataclasses import dataclass, field
-from typing import Optional
-
-from htmlBuilder.tags import HtmlTag
-
-from unstructured_ingest.connector.notion.interfaces import DBCellBase, DBPropertyBase
-from unstructured_ingest.connector.notion.types.date import Date as DateType
-
-
-@dataclass
-class Date(DBPropertyBase):
-    id: str
-    name: str
-    type: str = "date"
-    date: dict = field(default_factory=dict)
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        return cls(**data)
-
-
-@dataclass
-class DateCell(DBCellBase):
-    id: str
-    date: Optional[DateType] = None
-    name: Optional[str] = None
-    type: str = "date"
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        date = None
-        date_data = data.pop("date")
-        if date_data:
-            date = DateType.from_dict(date_data)
-        return cls(date=date, **data)
-
-    def get_html(self) -> Optional[HtmlTag]:
-        if date := self.date:
-            return date.get_html()
-        return None

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

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

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

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

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

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

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

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

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

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