dex-connector-calendly 0.1.0__tar.gz

dex_connector_calendly-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.DS_Store
+__pycache__/
+*.py[cod]
+node_modules/
+dist/
+sdkpython/dist/dex_connectors_sdk-0.1.0-py3-none-any.whl
+/.bin/dexcli
+/.bin/dex-server-zd
+/sdkpython/.dexcli-data/
+site/.catalog.yaml
+coverage/
+*.out
+*.test
+go.work
+go.work.sum
+.idea/

dex_connector_calendly-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Super Durable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dex_connector_calendly-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.5
+Name: dex-connector-calendly
+Version: 0.1.0
+Summary: Dex-native Calendly scheduling connector
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: dex-connectors-sdk==0.7.0
+Requires-Dist: dex-python-sdk>=1.28.0
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# Calendly Python connector
+
+Calendly scheduled events, invitees, cancellation, scheduling links, and webhook subscriptions for Dex Flows.
+
+The package implements six operations: `listScheduledEvents`, `getScheduledEvent`, `listEventInvitees`, `cancelScheduledEvent`, `createSchedulingLink`, and `createWebhookSubscription`. OAuth and personal access token decoding, refresh, and project connection wiring are manifest-generated. The invitee webhook Trigger remains Go-only.
+
+See [the scheduled event example](examples/scheduled_event/README.md) for the static `calendly-scheduling` connection and Worker entrypoint. The connector source defines every operation's request and result type; the generated Step factories expose the stable branches. The `createSchedulingLink` Mutation uses Dex's single-dispatch fence and returns `uncertain` when a possibly accepted write cannot be confirmed.

dex_connector_calendly-0.1.0/README.md

@@ -0,0 +1,7 @@
+# Calendly Python connector
+
+Calendly scheduled events, invitees, cancellation, scheduling links, and webhook subscriptions for Dex Flows.
+
+The package implements six operations: `listScheduledEvents`, `getScheduledEvent`, `listEventInvitees`, `cancelScheduledEvent`, `createSchedulingLink`, and `createWebhookSubscription`. OAuth and personal access token decoding, refresh, and project connection wiring are manifest-generated. The invitee webhook Trigger remains Go-only.
+
+See [the scheduled event example](examples/scheduled_event/README.md) for the static `calendly-scheduling` connection and Worker entrypoint. The connector source defines every operation's request and result type; the generated Step factories expose the stable branches. The `createSchedulingLink` Mutation uses Dex's single-dispatch fence and returns `uncertain` when a possibly accepted write cannot be confirmed.

dex_connector_calendly-0.1.0/examples/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Runnable Calendly Dex applications."""

dex_connector_calendly-0.1.0/examples/scheduled_event/README.md

@@ -0,0 +1,7 @@
+# Scheduled event lookup
+
+This runnable Python Flow reads one Calendly scheduled event and saves the safe event result. Configure a Dex Web connection named `calendly-scheduling` using either a personal access token or Calendly OAuth. The connection's authorization guide links to Calendly's token and OAuth application pages and lists the scopes.
+
+Start a local Dex stack with `dexcli dev -dex-port 40850 -web-port 40851 -open=false`, then run `DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40850 uv run python -m examples.scheduled_event.worker` from `connectors/calendly/python`. In another terminal, run `DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40850 uv run python -m examples.scheduled_event.start <unique-flow-id> https://api.calendly.com/scheduled_events/<id>`.
+
+Generate a strict FDG 2.0 graph from `connectors/calendly/python` with `dexcli visualize ./examples/scheduled_event/flow.py --language python --python .venv/bin/python --schema-version 2.0 --json --out ./build/calendly-scheduled-event`. The sole provider Query exposes the `found` branch; optional rejection branches fail the Flow when selected.

dex_connector_calendly-0.1.0/examples/scheduled_event/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Scheduled event lookup example."""

dex_connector_calendly-0.1.0/examples/scheduled_event/flow.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Read one Calendly scheduled event through a real Dex Query Step."""
+
+import dex
+from dex_connectors.sdk import QueryResult
+
+from dex_connectors.calendly import (
+    Connection,
+    GetScheduledEventInput,
+    ScheduledEvent,
+    new_get_scheduled_event_step,
+)
+
+CONNECTION_NAME = "calendly-scheduling"
+FLOW_TYPE = "CalendlyScheduledEventPython"
+EVENT = dex.Attribute("calendly-python-scheduled-event", ScheduledEvent)
+
+
+# dex:group group-id:scheduled-event group-label:"Scheduled event"
+# dex:explanation text:"Persist the scheduled event returned by Calendly."
+class CompleteEventLookup(dex.Step[QueryResult[ScheduledEvent]]):
+    """Complete the Flow with a safe event record."""
+
+    def execute(self, context: dex.Context, input: QueryResult[ScheduledEvent]) -> dex.StepDecision:
+        """Record the returned event and complete."""
+        EVENT.set(context, input.value)
+        return dex.graceful_complete(input.value)
+
+
+class ScheduledEventFlow(dex.Flow[GetScheduledEventInput]):
+    """Look up one event using the configured Calendly connection."""
+
+    def __init__(self, connection: Connection) -> None:
+        if connection.reference.name != CONNECTION_NAME:
+            raise ValueError("scheduled event example requires its static Calendly connection")
+        self.complete = CompleteEventLookup()
+        self.lookup = new_get_scheduled_event_step(
+            step_type="GetScheduledEvent",
+            step_input_type=GetScheduledEventInput,
+            annotations={
+                "groupId": "scheduled-event",
+                "groupLabel": "Scheduled event",
+                "explanation": "Read the selected scheduled event from Calendly.",
+            },
+            connection=connection,
+            connection_name=CONNECTION_NAME,
+            map_to_operation_input=lambda input: input,
+            found=self.complete,
+        )
+
+    def get_flow_type(self) -> str:
+        """Return the stable Flow type."""
+        return "CalendlyScheduledEventPython"
+
+    def get_steps(self) -> dex.StepList[GetScheduledEventInput]:
+        """Register the provider Query and completion Step."""
+        return dex.StepList.start_step(self.lookup).other_steps(self.complete)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        """Register the event Attribute consumed by this Flow."""
+        return dex.PersistenceSchema.of(EVENT)

dex_connector_calendly-0.1.0/examples/scheduled_event/integration_test.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Exercise the scheduled event example through a real Dex Worker and Client."""
+
+import asyncio
+import os
+import tempfile
+from datetime import timedelta
+from pathlib import Path
+from uuid import uuid4
+
+import dex
+import httpx
+import pytest
+from dex_connectors.sdk import ConnectionRef, SecretString, StaticCredentialProvider
+
+from dex_connectors.calendly import (
+    Client,
+    Config,
+    Credentials,
+    GetScheduledEventInput,
+    ScheduledEvent,
+    new_connection,
+)
+
+from .flow import CONNECTION_NAME, ScheduledEventFlow
+
+EVENT_URI = "https://api.calendly.com/scheduled_events/EVT00001"
+CONNECTION = ConnectionRef("calendly", CONNECTION_NAME)
+
+
+@pytest.mark.asyncio
+async def test_lookup_retries_and_fails_unwired_rejection_in_real_dex() -> None:
+    """Verify a retry, successful persistence, and optional branch failure."""
+    server_address = os.environ["DEX_FLOW_SERVICE_ADDRESS"]
+    requests: list[httpx.Request] = []
+
+    def answer(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path.endswith("EVT404"):
+            return httpx.Response(404, json={"title": "Not found"})
+        if len(requests) == 1:
+            return httpx.Response(503, json={"title": "Unavailable"})
+        return httpx.Response(
+            200,
+            json={
+                "resource": {
+                    "uri": EVENT_URI,
+                    "name": "Discovery Call",
+                    "status": "active",
+                    "start_time": "2026-11-02T17:00:00Z",
+                    "end_time": "2026-11-02T17:30:00Z",
+                }
+            },
+        )
+
+    async with httpx.AsyncClient(transport=httpx.MockTransport(answer)) as provider_http:
+        client = Client(
+            Config(),
+            StaticCredentialProvider({CONNECTION: Credentials(access_token=SecretString("inert-token"))}),
+            provider_http,
+        )
+        connection = new_connection(client, CONNECTION)
+        flow = ScheduledEventFlow(connection)
+        registry = dex.Registry([flow], allow_async_handlers=True)
+        with tempfile.TemporaryDirectory(prefix="calendly-python-dex-blobs-") as cache_directory:
+            cache = dex.open_blob_cache(dex.BlobCacheConfig(str(Path(cache_directory) / "blobs"), 1 << 24))
+            worker = dex.AsyncWorker(registry, cache, dex.WorkerOptions(server_address=server_address))
+            worker_task = asyncio.create_task(worker.start())
+            try:
+                await worker.wait_pull_registered(timeout=15)
+                async with dex.AsyncClient(
+                    registry, cache, dex.ClientOptions(server_address=server_address)
+                ) as dex_client:
+                    success_id = f"calendly-python-event-{uuid4().hex}"
+                    await dex_client.start_flow(flow, success_id, GetScheduledEventInput(EVENT_URI))
+                    success = await asyncio.wait_for(
+                        dex_client.wait_for_flow(success_id, timedelta(seconds=20)), 30
+                    )
+                    assert success.status == dex.FlowStatus.COMPLETED, success.error_message
+                    assert success.single_output(ScheduledEvent).uri == EVENT_URI
+                    assert len(requests) == 2
+                    rejected_id = f"calendly-python-event-{uuid4().hex}"
+                    await dex_client.start_flow(
+                        flow,
+                        rejected_id,
+                        GetScheduledEventInput("https://api.calendly.com/scheduled_events/EVT404"),
+                    )
+                    rejected = await asyncio.wait_for(
+                        dex_client.wait_for_flow(rejected_id, timedelta(seconds=20)), 30
+                    )
+                    assert rejected.status == dex.FlowStatus.FAILED
+                    assert rejected.error_message is not None and "notFound" in rejected.error_message
+            finally:
+                await worker.stop()
+                await worker_task
+                cache.close()

dex_connector_calendly-0.1.0/examples/scheduled_event/start.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Submit a scheduled event lookup to Dex."""
+
+import argparse
+import asyncio
+import os
+import tempfile
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.calendly import GetScheduledEventInput, new_project_connection
+
+from .flow import CONNECTION_NAME, ScheduledEventFlow
+
+
+async def start_lookup(flow_id: str, scheduled_event_uri: str) -> str:
+    """Start a lookup with a unique Flow ID and stable Calendly event URI."""
+    project = await load_from_environment()
+    connection = new_project_connection(project, CONNECTION_NAME)
+    try:
+        flow = ScheduledEventFlow(connection)
+        registry = dex.Registry([flow], allow_async_handlers=True)
+        with tempfile.TemporaryDirectory(prefix="calendly-python-start-blobs-") as cache_path:
+            cache = dex.open_blob_cache(dex.BlobCacheConfig(cache_path, 1 << 24))
+            try:
+                async with dex.AsyncClient(
+                    registry,
+                    cache,
+                    dex.ClientOptions(
+                        server_address=os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")
+                    ),
+                ) as client:
+                    return await client.start_flow(flow, flow_id, GetScheduledEventInput(scheduled_event_uri))
+            finally:
+                cache.close()
+    finally:
+        await connection.aclose()
+        await project.close()
+
+
+def main() -> None:
+    """Accept a Flow ID and Calendly event URI from the command line."""
+    parser = argparse.ArgumentParser(description="Start a Calendly event lookup")
+    parser.add_argument("flow_id")
+    parser.add_argument("scheduled_event_uri")
+    options = parser.parse_args()
+    print(asyncio.run(start_lookup(options.flow_id, options.scheduled_event_uri)))
+
+
+if __name__ == "__main__":
+    main()

dex_connector_calendly-0.1.0/examples/scheduled_event/worker.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Serve the Calendly scheduled event Flow using Dex Web Connections."""
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.calendly import new_project_connection
+
+from .flow import CONNECTION_NAME, ScheduledEventFlow
+
+
+async def run_worker() -> None:
+    """Load the named connection and run the Flow Worker until shutdown."""
+    project = await load_from_environment()
+    connection = None
+    cache = None
+    try:
+        connection = new_project_connection(project, CONNECTION_NAME)
+        registry = dex.Registry([ScheduledEventFlow(connection)], allow_async_handlers=True)
+        cache_path = os.environ.get(
+            "DEX_BLOB_CACHE_DIR", str(Path(tempfile.gettempdir()) / "dex-calendly-python-blobs")
+        )
+        cache = dex.open_blob_cache(dex.BlobCacheConfig(cache_path, 1 << 30))
+        async with dex.AsyncWorker(
+            registry,
+            cache,
+            dex.WorkerOptions(server_address=os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")),
+        ) as worker:
+            await worker.start()
+    finally:
+        if connection is not None:
+            await connection.aclose()
+        if cache is not None:
+            cache.close()
+        await project.close()
+
+
+def main() -> None:
+    """Run the Worker from a module invocation."""
+    asyncio.run(run_worker())
+
+
+if __name__ == "__main__":
+    main()

dex_connector_calendly-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dex-connector-calendly"
+version = "0.1.0"
+description = "Dex-native Calendly scheduling connector"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["dex-connectors-sdk==0.7.0", "dex-python-sdk>=1.28.0", "httpx>=0.27"]
+
+[dependency-groups]
+dev = ["pytest>=8", "pytest-asyncio>=0.24", "mypy>=1.13", "ruff>=0.7", "PyYAML>=6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dex_connectors"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+mypy_path = "src"
+explicit_package_bases = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 110
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

dex_connector_calendly-0.1.0/src/dex_connectors/calendly/__init__.py

@@ -0,0 +1,150 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Calendly scheduling operations for Dex Flows."""
+
+from ._generated.definitions import *  # noqa: F403
+from .client import Client as Client
+from .client import Config as Config
+from .client import Credentials as Credentials
+from .connection import (
+    Connection as Connection,
+)
+from .connection import (
+    new_connection as new_connection,
+)
+from .connection import (
+    new_connection_with_operations as new_connection_with_operations,
+)
+from .connection import (
+    new_project_connection as new_project_connection,
+)
+from .models import (
+    Cancellation as Cancellation,
+)
+from .models import (
+    CancelScheduledEventInput as CancelScheduledEventInput,
+)
+from .models import (
+    CreateSchedulingLinkInput as CreateSchedulingLinkInput,
+)
+from .models import (
+    CreateWebhookSubscriptionInput as CreateWebhookSubscriptionInput,
+)
+from .models import (
+    EventInviteePage as EventInviteePage,
+)
+from .models import (
+    GetScheduledEventInput as GetScheduledEventInput,
+)
+from .models import (
+    Invitee as Invitee,
+)
+from .models import (
+    InviteeAnswer as InviteeAnswer,
+)
+from .models import (
+    ListEventInviteesInput as ListEventInviteesInput,
+)
+from .models import (
+    ListScheduledEventsInput as ListScheduledEventsInput,
+)
+from .models import (
+    ScheduledEvent as ScheduledEvent,
+)
+from .models import (
+    ScheduledEventCancellation as ScheduledEventCancellation,
+)
+from .models import (
+    ScheduledEventHost as ScheduledEventHost,
+)
+from .models import (
+    ScheduledEventInviteesCounter as ScheduledEventInviteesCounter,
+)
+from .models import (
+    ScheduledEventLocation as ScheduledEventLocation,
+)
+from .models import (
+    ScheduledEventPage as ScheduledEventPage,
+)
+from .models import (
+    SchedulingLink as SchedulingLink,
+)
+from .models import (
+    WebhookSubscription as WebhookSubscription,
+)
+from .operations import (
+    CancelScheduledEventOperation as CancelScheduledEventOperation,
+)
+from .operations import (
+    CreateSchedulingLinkOperation as CreateSchedulingLinkOperation,
+)
+from .operations import (
+    CreateWebhookSubscriptionOperation as CreateWebhookSubscriptionOperation,
+)
+from .operations import (
+    GetScheduledEventOperation as GetScheduledEventOperation,
+)
+from .operations import (
+    ListEventInviteesOperation as ListEventInviteesOperation,
+)
+from .operations import (
+    ListScheduledEventsOperation as ListScheduledEventsOperation,
+)
+from .steps import (
+    new_cancel_scheduled_event_step as new_cancel_scheduled_event_step,
+)
+from .steps import (
+    new_create_scheduling_link_step as new_create_scheduling_link_step,
+)
+from .steps import (
+    new_create_webhook_subscription_step as new_create_webhook_subscription_step,
+)
+from .steps import (
+    new_get_scheduled_event_step as new_get_scheduled_event_step,
+)
+from .steps import (
+    new_list_event_invitees_step as new_list_event_invitees_step,
+)
+from .steps import (
+    new_list_scheduled_events_step as new_list_scheduled_events_step,
+)
+
+__all__ = [
+    "CancelScheduledEventInput",
+    "CancelScheduledEventOperation",
+    "Cancellation",
+    "Client",
+    "Config",
+    "Connection",
+    "CreateSchedulingLinkInput",
+    "CreateSchedulingLinkOperation",
+    "CreateWebhookSubscriptionInput",
+    "CreateWebhookSubscriptionOperation",
+    "Credentials",
+    "EventInviteePage",
+    "GetScheduledEventInput",
+    "GetScheduledEventOperation",
+    "Invitee",
+    "InviteeAnswer",
+    "ListEventInviteesInput",
+    "ListEventInviteesOperation",
+    "ListScheduledEventsInput",
+    "ListScheduledEventsOperation",
+    "ScheduledEvent",
+    "ScheduledEventCancellation",
+    "ScheduledEventHost",
+    "ScheduledEventInviteesCounter",
+    "ScheduledEventLocation",
+    "ScheduledEventPage",
+    "SchedulingLink",
+    "WebhookSubscription",
+    "new_cancel_scheduled_event_step",
+    "new_connection",
+    "new_connection_with_operations",
+    "new_create_scheduling_link_step",
+    "new_create_webhook_subscription_step",
+    "new_get_scheduled_event_step",
+    "new_list_event_invitees_step",
+    "new_list_scheduled_events_step",
+    "new_project_connection",
+]

dex_connector_calendly-0.1.0/src/dex_connectors/calendly/_generated/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT

dex_connector_calendly-0.1.0/src/dex_connectors/calendly/_generated/config.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+# ruff: noqa
+
+from dataclasses import dataclass
+
+from dex_connectors.sdk import SecretString
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+
+    max_response_bytes: int = 1048576
+    webhook_max_body_bytes: int = 1048576
+    webhook_signature_tolerance_seconds: float = 180
+
+setattr(Config, '__module__', 'dex_connectors.calendly.client')
+
+
+@dataclass(frozen=True, slots=True)
+class Credentials:
+
+    auth_method_id: str = "personal-access-token"
+    access_token: SecretString | None = None
+    webhook_signing_key: SecretString = SecretString('')
+    oauth_client_id: str | None = None
+    oauth_client_secret: SecretString | None = None
+    refresh_token: SecretString | None = None
+
+setattr(Credentials, '__module__', 'dex_connectors.calendly.client')