lfx-microsoft 0.1.0__py3-none-any.whl

lfx_microsoft/__init__.py

@@ -0,0 +1,25 @@
+"""Microsoft 365 and Teams components backed by delegated Microsoft Graph permissions."""
+
+from lfx_microsoft.components.microsoft import (
+    OutlookCalendarCreateComponent,
+    OutlookCalendarListComponent,
+    OutlookSearchComponent,
+    OutlookSendComponent,
+    SharePointFetchComponent,
+    SharePointListComponent,
+    TeamsChannelPostComponent,
+    TeamsChatPostComponent,
+)
+from lfx_microsoft.graph import GraphClient
+
+__all__ = [
+    "GraphClient",
+    "OutlookCalendarCreateComponent",
+    "OutlookCalendarListComponent",
+    "OutlookSearchComponent",
+    "OutlookSendComponent",
+    "SharePointFetchComponent",
+    "SharePointListComponent",
+    "TeamsChannelPostComponent",
+    "TeamsChatPostComponent",
+]

lfx_microsoft/base.py

@@ -0,0 +1,153 @@
+"""Shared base for every Microsoft Graph action component.
+
+Each component declares one manifest capability. The base turns that into a
+credential lease, checks the active capability requirements,
+and wraps the provider call in the integration telemetry boundary.
+
+This module is also the bundle's import facade for the ``lfx`` field types.
+``lfx.custom.custom_component.component`` must be imported before ``lfx.io``
+or ``lfx.inputs`` -- importing the field types first leaves the component
+module half-initialized (a cold ``import lfx.io`` followed by
+``from lfx.custom.custom_component.component import Component`` raises
+``ImportError`` on lfx 1.13). Re-exporting the field types here means every
+component module has exactly one lfx-facing import and cannot get that order
+wrong.
+"""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from lfx.custom.custom_component.component import Component
+from lfx.integrations.capabilities import ScopeSet
+from lfx.integrations.errors import ScopeMissingError
+from lfx.integrations.telemetry import integration_action
+from lfx.io import (
+    BoolInput,
+    DataInput,
+    DropdownInput,
+    FileInput,
+    IntInput,
+    MessageTextInput,
+    MultilineInput,
+    Output,
+)
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+from lfx_microsoft.graph import PROVIDER_ID, GraphClient
+from lfx_microsoft.manifest import capability
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from lfx.integrations.models import CredentialLease, ResolvedCredential
+
+__all__ = [
+    "BoolInput",
+    "Data",
+    "DataInput",
+    "DropdownInput",
+    "FileInput",
+    "IntInput",
+    "Message",
+    "MessageTextInput",
+    "MicrosoftGraphComponent",
+    "MultilineInput",
+    "Output",
+    "as_dict_list",
+    "as_list",
+    "recipients",
+]
+
+
+class MicrosoftGraphComponent(Component):
+    """Base class for the delegated Microsoft Graph actions."""
+
+    icon = "Microsoft"
+    capability_id: ClassVar[str] = ""
+
+    # Test seam: an ``httpx.AsyncBaseTransport`` used instead of the network.
+    graph_transport: Any = None
+    graph_base_url: str | None = None
+
+    def lease(self) -> CredentialLease:
+        """Return the credential lease for the declared connection field."""
+        return self.resolve_connection("connection")
+
+    def client(self, lease: CredentialLease) -> GraphClient:
+        """Build a Graph client bound to ``lease``."""
+        kwargs: dict[str, Any] = {}
+        if self.graph_transport is not None:
+            kwargs["transport"] = self.graph_transport
+        if self.graph_base_url:
+            kwargs["base_url"] = self.graph_base_url
+        return GraphClient(lease, **kwargs)
+
+    def _preflight_scopes(self, credential: ResolvedCredential, inputs: dict[str, Any]) -> None:
+        """Fail before the network call when a conditional scope is missing.
+
+        The connection resolver enforces static and conditional input scopes.
+        This check also keeps direct action callers aligned with the manifest.
+        """
+        if not credential.scopes_verified:
+            return
+        missing = ScopeSet.covers(
+            capability(self.capability_id),
+            inputs,
+            credential.granted_scopes,
+            provider=PROVIDER_ID,
+        )
+        if missing:
+            raise ScopeMissingError(missing, provider=PROVIDER_ID)
+
+    @asynccontextmanager
+    async def action(self, lease: CredentialLease, inputs: dict[str, Any] | None = None) -> AsyncIterator[GraphClient]:
+        """Resolve, pre-flight, measure and normalize one Graph action."""
+        credential = await lease.get_credential()
+        self._preflight_scopes(credential, inputs or {})
+        client = self.client(lease)
+        try:
+            async with integration_action(
+                self,
+                provider=PROVIDER_ID,
+                capability=self.capability_id,
+                owner_kind=credential.owner_kind,
+            ):
+                yield client
+        finally:
+            await client.aclose()
+
+
+def as_list(value: Any) -> list[str]:
+    """Normalize a possibly-scalar, possibly-comma-separated input into a list."""
+    if value is None:
+        return []
+    if isinstance(value, str):
+        items = [entry.strip() for entry in value.replace(";", ",").split(",")]
+    elif isinstance(value, (list, tuple, set)):
+        items = [str(entry).strip() for entry in value]
+    else:
+        items = [str(value).strip()]
+    return [item for item in items if item]
+
+
+def as_dict_list(value: Any) -> list[dict[str, Any]]:
+    """Normalize a Data / dict / list input into a list of plain dictionaries."""
+    if value is None:
+        return []
+    items = value if isinstance(value, (list, tuple)) else [value]
+    normalized: list[dict[str, Any]] = []
+    for item in items:
+        data = getattr(item, "data", None)
+        if isinstance(data, dict):
+            normalized.append(dict(data))
+        elif isinstance(item, dict):
+            normalized.append(item)
+    return normalized
+
+
+def recipients(addresses: Any) -> list[dict[str, dict[str, str]]]:
+    """Build a Graph ``emailAddress`` recipient list."""
+    return [{"emailAddress": {"address": address}} for address in as_list(addresses)]

lfx_microsoft/components/__init__.py

@@ -0,0 +1 @@
+"""Component packages shipped by lfx-microsoft."""

lfx_microsoft/components/microsoft/__init__.py

@@ -0,0 +1,19 @@
+from lfx_microsoft.components.microsoft.outlook_calendar_create import OutlookCalendarCreateComponent
+from lfx_microsoft.components.microsoft.outlook_calendar_list import OutlookCalendarListComponent
+from lfx_microsoft.components.microsoft.outlook_search import OutlookSearchComponent
+from lfx_microsoft.components.microsoft.outlook_send import OutlookSendComponent
+from lfx_microsoft.components.microsoft.sharepoint_fetch import SharePointFetchComponent
+from lfx_microsoft.components.microsoft.sharepoint_list import SharePointListComponent
+from lfx_microsoft.components.microsoft.teams_channel_post import TeamsChannelPostComponent
+from lfx_microsoft.components.microsoft.teams_chat_post import TeamsChatPostComponent
+
+__all__ = [
+    "OutlookCalendarCreateComponent",
+    "OutlookCalendarListComponent",
+    "OutlookSearchComponent",
+    "OutlookSendComponent",
+    "SharePointFetchComponent",
+    "SharePointListComponent",
+    "TeamsChannelPostComponent",
+    "TeamsChatPostComponent",
+]

lfx_microsoft/components/microsoft/capabilities.v1.json

@@ -0,0 +1,255 @@
+{
+  "schema_version": 1,
+  "provider_id": "microsoft",
+  "display_name": "Microsoft 365",
+  "icon": "Microsoft",
+  "docs_url": "https://docs.langflow.org/bundles-microsoft",
+  "auth_profiles": [
+    {
+      "id": "user",
+      "kind": "oauth2_authorization_code",
+      "identity": "user_delegated",
+      "authorization_url": "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize",
+      "token_url": "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token",
+      "supports_pkce": true,
+      "supports_refresh": true,
+      "scope_separator": " ",
+      "default_scopes": [
+        "offline_access"
+      ],
+      "client_type_by_context": {
+        "hosted": "confidential",
+        "self_managed": "confidential",
+        "desktop": "public",
+        "headless": "external"
+      },
+      "owner_by_context": {
+        "hosted": "langflow",
+        "self_managed": "customer",
+        "desktop": "langflow",
+        "headless": "customer"
+      },
+      "tenant_param": "tenant"
+    }
+  ],
+  "capabilities": [
+    {
+      "id": "microsoft.outlook.send",
+      "display_name": "Outlook: Send Mail",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "Mail.Send"
+      ],
+      "conditional_scopes": [],
+      "policy_keys": [
+        "integrations.microsoft.outlook.send"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "OutlookSendComponent"
+    },
+    {
+      "id": "microsoft.outlook.search",
+      "display_name": "Outlook: Search Mail",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "Mail.Read"
+      ],
+      "conditional_scopes": [],
+      "policy_keys": [
+        "integrations.microsoft.outlook.search"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "read",
+      "component_ref": "OutlookSearchComponent"
+    },
+    {
+      "id": "microsoft.calendar.list",
+      "display_name": "Outlook Calendar: List Events",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "Calendars.Read"
+      ],
+      "conditional_scopes": [],
+      "policy_keys": [
+        "integrations.microsoft.calendar.list"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "read",
+      "component_ref": "OutlookCalendarListComponent"
+    },
+    {
+      "id": "microsoft.calendar.create",
+      "display_name": "Outlook Calendar: Create Event",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "Calendars.ReadWrite"
+      ],
+      "conditional_scopes": [],
+      "policy_keys": [
+        "integrations.microsoft.calendar.create"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "OutlookCalendarCreateComponent"
+    },
+    {
+      "id": "microsoft.teams.chat_post",
+      "display_name": "Teams: Post Chat Message",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "ChatMessage.Send"
+      ],
+      "conditional_scopes": [],
+      "policy_keys": [
+        "integrations.microsoft.teams.chat_post"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "TeamsChatPostComponent"
+    },
+    {
+      "id": "microsoft.teams.channel_post",
+      "display_name": "Teams: Post Channel Message",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "ChannelMessage.Send"
+      ],
+      "conditional_scopes": [],
+      "policy_keys": [
+        "integrations.microsoft.teams.channel_post"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "write",
+      "component_ref": "TeamsChannelPostComponent"
+    },
+    {
+      "id": "microsoft.files.list",
+      "display_name": "SharePoint/OneDrive: List Items",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "Files.Read"
+      ],
+      "conditional_scopes": [
+        {
+          "scope": "Files.Read.All",
+          "role": "optional",
+          "condition": {
+            "kind": "input_truthy",
+            "input": "drive_id"
+          }
+        },
+        {
+          "scope": "Sites.Read.All",
+          "role": "optional",
+          "condition": {
+            "kind": "input_truthy",
+            "input": "site_id"
+          }
+        }
+      ],
+      "policy_keys": [
+        "integrations.microsoft.files.list"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "read",
+      "component_ref": "SharePointListComponent"
+    },
+    {
+      "id": "microsoft.files.fetch",
+      "display_name": "SharePoint/OneDrive: Fetch Item",
+      "auth_profile_id": "user",
+      "identity": "user_delegated",
+      "required_scopes": [
+        "Files.Read"
+      ],
+      "conditional_scopes": [
+        {
+          "scope": "Files.Read.All",
+          "role": "optional",
+          "condition": {
+            "kind": "input_truthy",
+            "input": "drive_id"
+          }
+        },
+        {
+          "scope": "Sites.Read.All",
+          "role": "optional",
+          "condition": {
+            "kind": "input_truthy",
+            "input": "site_id"
+          }
+        }
+      ],
+      "policy_keys": [
+        "integrations.microsoft.files.fetch"
+      ],
+      "substrate": "rest",
+      "maturity": "ga",
+      "deployment_contexts": [
+        "hosted",
+        "self_managed",
+        "desktop",
+        "headless"
+      ],
+      "risk": "read",
+      "component_ref": "SharePointFetchComponent"
+    }
+  ]
+}

lfx_microsoft/components/microsoft/outlook_calendar_create.py

@@ -0,0 +1,132 @@
+"""Create a calendar event (POST /me/events)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from lfx_microsoft.base import (
+    BoolInput,
+    Data,
+    DataInput,
+    MessageTextInput,
+    MicrosoftGraphComponent,
+    MultilineInput,
+    Output,
+    as_list,
+)
+from lfx_microsoft.graph import prefer_header
+from lfx_microsoft.manifest import connection_input
+
+DEFAULT_TIME_ZONE = "UTC"
+
+
+class OutlookCalendarCreateComponent(MicrosoftGraphComponent):
+    """Create an Outlook calendar event as the connected user."""
+
+    display_name = "Outlook Calendar: Create Event"
+    description = "Create a calendar event on the connected user's calendar."
+    documentation = "https://learn.microsoft.com/en-us/graph/api/user-post-events"
+    name = "OutlookCalendarCreateEvent"
+    capability_id = "microsoft.calendar.create"
+
+    inputs = [
+        connection_input(capability_id),
+        MessageTextInput(name="subject", display_name="Subject", required=True),
+        MessageTextInput(
+            name="start_time",
+            display_name="Start",
+            info="ISO 8601 local start, for example 2026-09-01T09:00:00.",
+            required=True,
+        ),
+        MessageTextInput(name="end_time", display_name="End", info="ISO 8601 local end.", required=True),
+        MessageTextInput(
+            name="time_zone",
+            display_name="Time Zone",
+            info="dateTimeTimeZone.timeZone for both ends. Defaults to UTC.",
+            value=DEFAULT_TIME_ZONE,
+        ),
+        MultilineInput(name="body", display_name="Body", advanced=True),
+        MessageTextInput(name="location", display_name="Location", advanced=True),
+        MessageTextInput(
+            name="attendees",
+            display_name="Attendees",
+            info="Required attendee addresses.",
+            is_list=True,
+            advanced=True,
+        ),
+        BoolInput(name="is_online_meeting", display_name="Online Meeting", value=False, advanced=True),
+        DataInput(
+            name="recurrence",
+            display_name="Recurrence",
+            info="A Graph patternedRecurrence object.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="calendar_id",
+            display_name="Calendar ID",
+            info="Defaults to the user's default calendar.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="transaction_id",
+            display_name="Transaction ID",
+            info="Client-supplied id that makes a retried create idempotent.",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [Output(display_name="Event", name="event", method="create_event")]
+
+    def _path(self) -> str:
+        calendar = (self.calendar_id or "").strip()
+        if calendar:
+            return f"/me/calendars/{calendar}/events"
+        return "/me/events"
+
+    def _recurrence(self) -> dict[str, Any] | None:
+        value = self.recurrence
+        if value is None:
+            return None
+        if isinstance(value, Data):
+            return dict(value.data)
+        if isinstance(value, dict):
+            return value
+        return None
+
+    def _event(self) -> dict[str, Any]:
+        time_zone = (self.time_zone or "").strip() or DEFAULT_TIME_ZONE
+        event: dict[str, Any] = {
+            "subject": self.subject,
+            "start": {"dateTime": self.start_time, "timeZone": time_zone},
+            "end": {"dateTime": self.end_time, "timeZone": time_zone},
+        }
+        if body := (self.body or ""):
+            event["body"] = {"contentType": "text", "content": body}
+        if location := (self.location or "").strip():
+            event["location"] = {"displayName": location}
+        if attendees := as_list(self.attendees):
+            event["attendees"] = [{"emailAddress": {"address": address}, "type": "required"} for address in attendees]
+        if self.is_online_meeting:
+            event["isOnlineMeeting"] = True
+        if recurrence := self._recurrence():
+            event["recurrence"] = recurrence
+        if transaction_id := (self.transaction_id or "").strip():
+            event["transactionId"] = transaction_id
+        return event
+
+    async def create_event(self) -> Data:
+        """Create the event and return the created Graph resource."""
+        payload = self._event()
+        headers = prefer_header((self.time_zone or "").strip() or DEFAULT_TIME_ZONE)
+        lease = self.lease()
+        async with self.action(lease) as client:
+            response = await client.request(
+                "POST",
+                self._path(),
+                json_body=payload,
+                headers=headers or None,
+            )
+        created = response.json() if response.content else {}
+        result = Data(data=created if isinstance(created, dict) else {"response": created})
+        self.status = result.data.get("id", "created")
+        return result