contextbase-plugin-google-calendar 0.2.3__py3-none-any.whl

contextbase_plugin_google_calendar-0.2.3.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.3
+Name: contextbase-plugin-google-calendar
+Version: 0.2.3
+Summary: Google Calendar plugin for ContextBase
+Author: Alizain Feerasta
+Author-email: Alizain Feerasta <alizain.feerasta@gmail.com>
+Requires-Dist: contextbase-shared-plugins==0.2.3
+Requires-Dist: dagster==1.12.14
+Requires-Dist: dagster-dlt==0.28.14
+Requires-Dist: dlt>=1.26.0
+Requires-Dist: google-api-python-client>=2.185.0
+Requires-Dist: pydantic>=2.12.0
+Requires-Python: >=3.14, <3.15

contextbase_plugin_google_calendar-0.2.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+plugin_google_calendar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_google_calendar/binding_config.py,sha256=ywTFcaL5NnKKjc3c-Kx0XJTdAIVHfF9Oxuquew-c6GY,165
+plugin_google_calendar/component.py,sha256=VHDK5ZuBz7E0aTHYA07SlWhGTmCk_e7TabCGOb_Tl40,4212
+plugin_google_calendar/defs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_google_calendar/defs/defs.yaml,sha256=RWet1IW81pbom10Badvi6xu9RFcTUcDBvhbT8XCUybY,67
+plugin_google_calendar/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_google_calendar/models/ctx.py,sha256=UP2pXtTZD9bflxIUegCaX-12CWfnCs7-bWvG3VcJ1p4,3263
+plugin_google_calendar/models/ingress.py,sha256=vV5tUlX6JLXuMH52tdBuYGhzDGSlnfOY_Gjn2szUHNw,13797
+plugin_google_calendar/models/translators.py,sha256=Ji8-3T19hjvVp01i-7VaYBZe2Hn1uyLGgX_kI7qg_es,7225
+plugin_google_calendar/plugin.json,sha256=x1zAlAetAtZwfvIdRht5SXqWjWxHgSEpuNqN5VbxGIk,183
+plugin_google_calendar/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_google_calendar/sources/sync.py,sha256=hFbtIN6GiiZaE7QBY4T6GUu2wcddSFhSCIxGiTzl_u8,8403
+plugin_google_calendar/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plugin_google_calendar/utils/client.py,sha256=xhGt_1T7uH5lzy3TZFGAdgFuwjTpp4k3JtFN1vmss6o,3673
+contextbase_plugin_google_calendar-0.2.3.dist-info/WHEEL,sha256=i9aSRDivn5iP9LaR1BLQX2GNAuriQWPsFwbbWygTX2k,81
+contextbase_plugin_google_calendar-0.2.3.dist-info/METADATA,sha256=2DfwQiqk-EZFrZuiMPu-3X63p3Zp1pgKXLn_mNFYnBE,467
+contextbase_plugin_google_calendar-0.2.3.dist-info/RECORD,,

contextbase_plugin_google_calendar-0.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.15
+Root-Is-Purelib: true
+Tag: py3-none-any

plugin_google_calendar/binding_config.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from shared_plugins.bindings import BaseBindingConfigModel
+
+
+class GoogleCalendarBindingConfig(BaseBindingConfigModel):
+    pass

plugin_google_calendar/component.py

@@ -0,0 +1,126 @@
+import dagster as dg
+from dagster import AssetExecutionContext
+from dagster_dlt import DagsterDltResource
+from shared_plugins.automation import non_overlapping_automation_condition
+from shared_plugins.bindings import (
+    parse_binding_config,
+    require_authenticated_account,
+)
+from shared_plugins.control_plane import ControlPlaneClient
+from shared_plugins.dlt import resolve_partition_binding, run_dlt_pipeline
+from shared_plugins.google_client.auth import (
+    build_google_service,
+)
+from shared_plugins.resources import DLT_RESOURCE
+from shared_plugins.naming import (
+    dagster_asset_group_name,
+    dagster_asset_tags,
+    dagster_dlt_asset_key,
+    dagster_partition_def_name,
+    dagster_pool_name,
+    dlt_source_name,
+    plugin_id_from_module,
+)
+
+from .binding_config import GoogleCalendarBindingConfig
+from .sources.sync import google_calendar_sync_source
+from .utils.client import (
+    GoogleCalendarApiClient,
+)
+
+PLUGIN_ID = plugin_id_from_module(__file__)
+SYNC_JOB = "sync"
+SYNC_SOURCE_NAME = dlt_source_name(PLUGIN_ID, SYNC_JOB)
+
+
+def _build_sync_specs(
+    partitions_def: dg.PartitionsDefinition,
+    automation_condition: dg.AutomationCondition,
+) -> list[dg.AssetSpec]:
+    shared = dict(
+        group_name=dagster_asset_group_name(PLUGIN_ID),
+        tags=dagster_asset_tags(PLUGIN_ID),
+        automation_condition=automation_condition,
+        partitions_def=partitions_def,
+    )
+
+    calendars_key = dagster_dlt_asset_key(SYNC_SOURCE_NAME, "calendars")
+    return [
+        dg.AssetSpec(key=calendars_key, **shared),
+        dg.AssetSpec(
+            key=dagster_dlt_asset_key(SYNC_SOURCE_NAME, "events"),
+            deps=[calendars_key],
+            **shared,
+        ),
+    ]
+
+
+class GoogleCalendarSyncComponent(dg.Component):
+    def build_defs(self, context: dg.ComponentLoadContext) -> dg.Definitions:
+        partitions_def = dg.DynamicPartitionsDefinition(
+            name=dagster_partition_def_name(PLUGIN_ID)
+        )
+
+        sync_specs = _build_sync_specs(
+            partitions_def,
+            non_overlapping_automation_condition(
+                dg.AutomationCondition.on_missing()
+                | dg.AutomationCondition.on_cron("*/15 * * * *")
+            ),
+        )
+
+        @dg.multi_asset(
+            specs=sync_specs,
+            can_subset=True,
+            name="google_calendar_sync",
+            pool=dagster_pool_name(PLUGIN_ID),
+        )
+        def google_calendar_sync_assets(
+            context: AssetExecutionContext,
+            dlt_resource: DagsterDltResource,
+            control_plane: dg.ResourceParam[ControlPlaneClient],
+        ):
+            binding = resolve_partition_binding(
+                context=context,
+                control_plane=control_plane,
+                plugin_id=PLUGIN_ID,
+            )
+            binding_id = str(binding.binding_id)
+            parse_binding_config(binding, GoogleCalendarBindingConfig)
+            authenticated_account = require_authenticated_account(binding)
+            client = GoogleCalendarApiClient(
+                service=build_google_service(
+                    api_name="calendar",
+                    api_version="v3",
+                    auth=authenticated_account,
+                    control_plane=control_plane,
+                ),
+            )
+
+            source = google_calendar_sync_source(
+                binding_id,
+                client=client,
+            )
+            yield from run_dlt_pipeline(
+                context=context,
+                dlt_resource=dlt_resource,
+                source=source,
+                plugin_id=PLUGIN_ID,
+                binding_id=binding_id,
+                job_name=SYNC_JOB,
+            )
+
+        automation_sensor = dg.AutomationConditionSensorDefinition(
+            name="google_calendar_automation_sensor",
+            target=dg.AssetSelection.assets(google_calendar_sync_assets),
+            default_status=dg.DefaultSensorStatus.RUNNING,
+            minimum_interval_seconds=30,
+        )
+
+        return dg.Definitions(
+            assets=[google_calendar_sync_assets],
+            sensors=[automation_sensor],
+            resources={
+                "dlt_resource": DLT_RESOURCE,
+            },
+        )

plugin_google_calendar/defs/defs.yaml

@@ -0,0 +1 @@
+type: plugin_google_calendar.component.GoogleCalendarSyncComponent

plugin_google_calendar/models/ctx.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import AwareDatetime
+from shared_plugins.models import CtxModel, IdStr, NonNegativeInt
+
+
+class CalendarRow(CtxModel):
+    id: IdStr
+    etag: str | None = None
+    summary: str | None = None
+    summary_override: str | None = None
+    description: str | None = None
+    location: str | None = None
+    time_zone: str | None = None
+    access_role: str | None = None
+    primary: bool | None = None
+    selected: bool | None = None
+    hidden: bool | None = None
+    is_deleted: bool = False
+    auto_accept_invitations: bool | None = None
+    data_owner: str | None = None
+    color_id: str | None = None
+    background_color: str | None = None
+    foreground_color: str | None = None
+    default_reminders: list[dict[str, Any]] | None = None
+    notification_settings: dict[str, Any] | None = None
+    conference_properties: dict[str, Any] | None = None
+
+
+class EventRow(CtxModel):
+    calendar_id: IdStr
+    id: IdStr
+    etag: str | None = None
+    status: str | None = None
+    event_type: str | None = None
+    is_cancelled: bool = False
+    is_all_day: bool = False
+    is_recurring_instance: bool = False
+    i_cal_uid: str | None = None
+    recurring_event_id: str | None = None
+    sequence: NonNegativeInt | None = None
+    original_start_date: str | None = None
+    original_start_date_time: AwareDatetime | None = None
+    original_start_time_zone: str | None = None
+    summary: str | None = None
+    description: str | None = None
+    location: str | None = None
+    color_id: str | None = None
+    html_link: str | None = None
+    hangout_link: str | None = None
+    creator_email: str | None = None
+    creator_display_name: str | None = None
+    creator_self: bool | None = None
+    organizer_email: str | None = None
+    organizer_display_name: str | None = None
+    organizer_self: bool | None = None
+    created_at: AwareDatetime | None = None
+    updated_at: AwareDatetime | None = None
+    start_date: str | None = None
+    start_date_time: AwareDatetime | None = None
+    start_time_zone: str | None = None
+    end_date: str | None = None
+    end_date_time: AwareDatetime | None = None
+    end_time_zone: str | None = None
+    end_time_unspecified: bool | None = None
+    transparency: str | None = None
+    visibility: str | None = None
+    locked: bool | None = None
+    private_copy: bool | None = None
+    attendees_omitted: bool | None = None
+    anyone_can_add_self: bool | None = None
+    guests_can_invite_others: bool | None = None
+    guests_can_modify: bool | None = None
+    guests_can_see_other_guests: bool | None = None
+    recurrence: list[str] | None = None
+    attendees: list[dict[str, Any]] | None = None
+    attachments: list[dict[str, Any]] | None = None
+    conference_data: dict[str, Any] | None = None
+    reminders: dict[str, Any] | None = None
+    source: dict[str, Any] | None = None
+    extended_properties_private: dict[str, str] | None = None
+    extended_properties_shared: dict[str, str] | None = None
+    out_of_office_properties: dict[str, Any] | None = None
+    focus_time_properties: dict[str, Any] | None = None
+    working_location_properties: dict[str, Any] | None = None
+    birthday_properties: dict[str, Any] | None = None

plugin_google_calendar/models/ingress.py

@@ -0,0 +1,384 @@
+from __future__ import annotations
+
+from pydantic import AwareDatetime, Field, field_validator
+from typing import Annotated
+
+from shared_plugins.models import IdStr, IngressModel
+from shared_plugins.values import parse_utc_datetime_from_str
+
+NonNegativeInt = Annotated[int, Field(ge=0, strict=True)]
+
+
+class CalendarDefaultReminderIngress(IngressModel):
+    method: str | None = None
+    minutes: NonNegativeInt | None = None
+
+
+class CalendarNotificationIngress(IngressModel):
+    type: str | None = None
+    method: str | None = None
+
+
+class CalendarNotificationSettingsIngress(IngressModel):
+    notifications: list[CalendarNotificationIngress] = Field(default_factory=list)
+
+
+class CalendarConferencePropertiesIngress(IngressModel):
+    allowed_conference_solution_types: list[str] = Field(
+        default_factory=list,
+        alias="allowedConferenceSolutionTypes",
+    )
+
+
+class GoogleCalendarCalendarListItemIngress(IngressModel):
+    kind: str | None = None
+    id: IdStr
+    etag: str | None = None
+    summary: str | None = None
+    summary_override: str | None = Field(default=None, alias="summaryOverride")
+    description: str | None = None
+    location: str | None = None
+    time_zone: str | None = Field(default=None, alias="timeZone")
+    access_role: str | None = Field(default=None, alias="accessRole")
+    primary: bool | None = Field(default=None, strict=True)
+    selected: bool | None = Field(default=None, strict=True)
+    hidden: bool | None = Field(default=None, strict=True)
+    deleted: bool | None = Field(default=None, strict=True)
+    auto_accept_invitations: bool | None = Field(
+        default=None, alias="autoAcceptInvitations", strict=True
+    )
+    data_owner: str | None = Field(default=None, alias="dataOwner")
+    color_id: str | None = Field(default=None, alias="colorId")
+    background_color: str | None = Field(default=None, alias="backgroundColor")
+    foreground_color: str | None = Field(default=None, alias="foregroundColor")
+    default_reminders: list[CalendarDefaultReminderIngress] = Field(
+        default_factory=list,
+        alias="defaultReminders",
+    )
+    notification_settings: CalendarNotificationSettingsIngress | None = Field(
+        default=None,
+        alias="notificationSettings",
+    )
+    conference_properties: CalendarConferencePropertiesIngress | None = Field(
+        default=None,
+        alias="conferenceProperties",
+    )
+
+
+class GoogleCalendarCalendarListResponseIngress(IngressModel):
+    kind: str | None = None
+    etag: str | None = None
+    items: list[GoogleCalendarCalendarListItemIngress] = Field(default_factory=list)
+    next_page_token: str | None = Field(default=None, alias="nextPageToken")
+    next_sync_token: str | None = Field(default=None, alias="nextSyncToken")
+
+
+class EventDateTimeIngress(IngressModel):
+    date: str | None = None
+    date_time: AwareDatetime | None = Field(default=None, alias="dateTime")
+    time_zone: str | None = Field(default=None, alias="timeZone")
+
+    @field_validator("date_time", mode="before")
+    @classmethod
+    def _coerce_date_time(cls, value: object) -> object:
+        if not isinstance(value, str):
+            return value
+        return parse_utc_datetime_from_str(value)
+
+
+class EventPersonIngress(IngressModel):
+    id: str | None = None
+    email: str | None = None
+    display_name: str | None = Field(default=None, alias="displayName")
+    is_self: bool | None = Field(default=None, alias="self", strict=True)
+
+
+class EventAttendeeIngress(EventPersonIngress):
+    organizer: bool | None = Field(default=None, strict=True)
+    resource: bool | None = Field(default=None, strict=True)
+    optional: bool | None = Field(default=None, strict=True)
+    response_status: str | None = Field(default=None, alias="responseStatus")
+    comment: str | None = None
+    additional_guests: NonNegativeInt | None = Field(
+        default=None,
+        alias="additionalGuests",
+    )
+
+
+class EventAttachmentIngress(IngressModel):
+    file_url: str | None = Field(default=None, alias="fileUrl")
+    title: str | None = None
+    mime_type: str | None = Field(default=None, alias="mimeType")
+    icon_link: str | None = Field(default=None, alias="iconLink")
+    file_id: str | None = Field(default=None, alias="fileId")
+
+
+class EventConferenceSolutionKeyIngress(IngressModel):
+    type: str | None = None
+
+
+class EventConferenceSolutionIngress(IngressModel):
+    key: EventConferenceSolutionKeyIngress | None = None
+    name: str | None = None
+    icon_uri: str | None = Field(default=None, alias="iconUri")
+
+
+class EventConferenceEntryPointIngress(IngressModel):
+    entry_point_type: str | None = Field(default=None, alias="entryPointType")
+    uri: str | None = None
+    label: str | None = None
+    pin: str | None = None
+    access_code: str | None = Field(default=None, alias="accessCode")
+    meeting_code: str | None = Field(default=None, alias="meetingCode")
+    passcode: str | None = None
+    password: str | None = None
+    region_code: str | None = Field(default=None, alias="regionCode")
+    entry_point_features: list[str] = Field(
+        default_factory=list,
+        alias="entryPointFeatures",
+    )
+
+
+class EventConferenceCreateRequestStatusIngress(IngressModel):
+    status_code: str | None = Field(default=None, alias="statusCode")
+
+
+class EventConferenceCreateRequestIngress(IngressModel):
+    request_id: str | None = Field(default=None, alias="requestId")
+    conference_solution_key: EventConferenceSolutionKeyIngress | None = Field(
+        default=None,
+        alias="conferenceSolutionKey",
+    )
+    status: EventConferenceCreateRequestStatusIngress | None = None
+
+
+class EventConferenceParametersAddOnIngress(IngressModel):
+    parameters: dict[str, str] = Field(default_factory=dict)
+
+
+class EventConferenceParametersIngress(IngressModel):
+    add_on_parameters: EventConferenceParametersAddOnIngress | None = Field(
+        default=None,
+        alias="addOnParameters",
+    )
+
+
+class EventConferenceDataIngress(IngressModel):
+    conference_id: str | None = Field(default=None, alias="conferenceId")
+    conference_solution: EventConferenceSolutionIngress | None = Field(
+        default=None,
+        alias="conferenceSolution",
+    )
+    entry_points: list[EventConferenceEntryPointIngress] = Field(
+        default_factory=list,
+        alias="entryPoints",
+    )
+    notes: str | None = None
+    signature: str | None = None
+    create_request: EventConferenceCreateRequestIngress | None = Field(
+        default=None,
+        alias="createRequest",
+    )
+    parameters: EventConferenceParametersIngress | None = None
+
+
+class EventGadgetIngress(IngressModel):
+    type: str | None = None
+    title: str | None = None
+    link: str | None = None
+    icon_link: str | None = Field(default=None, alias="iconLink")
+    width: NonNegativeInt | None = None
+    height: NonNegativeInt | None = None
+    display: str | None = None
+    preferences: dict[str, str] = Field(default_factory=dict)
+
+
+class EventReminderOverrideIngress(IngressModel):
+    method: str | None = None
+    minutes: NonNegativeInt | None = None
+
+
+class EventRemindersIngress(IngressModel):
+    use_default: bool | None = Field(default=None, alias="useDefault", strict=True)
+    overrides: list[EventReminderOverrideIngress] = Field(default_factory=list)
+
+
+class EventSourceIngress(IngressModel):
+    url: str | None = None
+    title: str | None = None
+
+
+class EventExtendedPropertiesIngress(IngressModel):
+    private: dict[str, str] = Field(default_factory=dict)
+    shared: dict[str, str] = Field(default_factory=dict)
+
+
+class EventOutOfOfficePropertiesIngress(IngressModel):
+    auto_decline_mode: str | None = Field(default=None, alias="autoDeclineMode")
+    decline_message: str | None = Field(default=None, alias="declineMessage")
+
+
+class EventFocusTimePropertiesIngress(IngressModel):
+    auto_decline_mode: str | None = Field(default=None, alias="autoDeclineMode")
+    decline_message: str | None = Field(default=None, alias="declineMessage")
+    chat_status: str | None = Field(default=None, alias="chatStatus")
+
+
+class EventWorkingLocationHomeOfficeIngress(IngressModel):
+    pass
+
+
+class EventWorkingLocationCustomLocationIngress(IngressModel):
+    label: str | None = None
+
+
+class EventWorkingLocationOfficeLocationIngress(IngressModel):
+    building_id: str | None = Field(default=None, alias="buildingId")
+    floor_id: str | None = Field(default=None, alias="floorId")
+    floor_section_id: str | None = Field(default=None, alias="floorSectionId")
+    desk_id: str | None = Field(default=None, alias="deskId")
+    label: str | None = None
+
+
+class EventWorkingLocationPropertiesIngress(IngressModel):
+    type: str | None = None
+    home_office: EventWorkingLocationHomeOfficeIngress | None = Field(
+        default=None,
+        alias="homeOffice",
+    )
+    custom_location: EventWorkingLocationCustomLocationIngress | None = Field(
+        default=None,
+        alias="customLocation",
+    )
+    office_location: EventWorkingLocationOfficeLocationIngress | None = Field(
+        default=None,
+        alias="officeLocation",
+    )
+
+
+class EventBirthdayPropertiesIngress(IngressModel):
+    contact: str | None = None
+    type: str | None = None
+    custom_type_name: str | None = Field(default=None, alias="customTypeName")
+
+
+class GoogleCalendarEventIngress(IngressModel):
+    kind: str | None = None
+    id: IdStr
+    etag: str | None = None
+    status: str | None = None
+    html_link: str | None = Field(default=None, alias="htmlLink")
+    created: AwareDatetime | None = None
+    updated: AwareDatetime | None = None
+    summary: str | None = None
+    description: str | None = None
+    location: str | None = None
+    color_id: str | None = Field(default=None, alias="colorId")
+    creator: EventPersonIngress | None = None
+    organizer: EventPersonIngress | None = None
+    start: EventDateTimeIngress | None = None
+    end: EventDateTimeIngress | None = None
+    end_time_unspecified: bool | None = Field(
+        default=None,
+        alias="endTimeUnspecified",
+        strict=True,
+    )
+    recurring_event_id: str | None = Field(default=None, alias="recurringEventId")
+    original_start_time: EventDateTimeIngress | None = Field(
+        default=None,
+        alias="originalStartTime",
+    )
+    transparency: str | None = None
+    visibility: str | None = None
+    i_cal_uid: str | None = Field(default=None, alias="iCalUID")
+    sequence: NonNegativeInt | None = None
+    attendees: list[EventAttendeeIngress] = Field(default_factory=list)
+    attendees_omitted: bool | None = Field(
+        default=None,
+        alias="attendeesOmitted",
+        strict=True,
+    )
+    hangout_link: str | None = Field(default=None, alias="hangoutLink")
+    conference_data: EventConferenceDataIngress | None = Field(
+        default=None,
+        alias="conferenceData",
+    )
+    gadget: EventGadgetIngress | None = None
+    anyone_can_add_self: bool | None = Field(
+        default=None,
+        alias="anyoneCanAddSelf",
+        strict=True,
+    )
+    guests_can_invite_others: bool | None = Field(
+        default=None,
+        alias="guestsCanInviteOthers",
+        strict=True,
+    )
+    guests_can_modify: bool | None = Field(
+        default=None,
+        alias="guestsCanModify",
+        strict=True,
+    )
+    guests_can_see_other_guests: bool | None = Field(
+        default=None,
+        alias="guestsCanSeeOtherGuests",
+        strict=True,
+    )
+    private_copy: bool | None = Field(default=None, alias="privateCopy", strict=True)
+    locked: bool | None = Field(default=None, strict=True)
+    reminders: EventRemindersIngress | None = None
+    source: EventSourceIngress | None = None
+    attachments: list[EventAttachmentIngress] = Field(default_factory=list)
+    event_type: str | None = Field(default=None, alias="eventType")
+    out_of_office_properties: EventOutOfOfficePropertiesIngress | None = Field(
+        default=None,
+        alias="outOfOfficeProperties",
+    )
+    focus_time_properties: EventFocusTimePropertiesIngress | None = Field(
+        default=None,
+        alias="focusTimeProperties",
+    )
+    working_location_properties: EventWorkingLocationPropertiesIngress | None = Field(
+        default=None,
+        alias="workingLocationProperties",
+    )
+    birthday_properties: EventBirthdayPropertiesIngress | None = Field(
+        default=None,
+        alias="birthdayProperties",
+    )
+    recurrence: list[str] = Field(default_factory=list)
+    extended_properties: EventExtendedPropertiesIngress | None = Field(
+        default=None,
+        alias="extendedProperties",
+    )
+
+    @field_validator("created", "updated", mode="before")
+    @classmethod
+    def _coerce_event_datetimes(cls, value: object) -> object:
+        if not isinstance(value, str):
+            return value
+        return parse_utc_datetime_from_str(value)
+
+
+class GoogleCalendarEventsListResponseIngress(IngressModel):
+    kind: str | None = None
+    etag: str | None = None
+    summary: str | None = None
+    description: str | None = None
+    updated: AwareDatetime | None = None
+    time_zone: str | None = Field(default=None, alias="timeZone")
+    access_role: str | None = Field(default=None, alias="accessRole")
+    default_reminders: list[EventReminderOverrideIngress] = Field(
+        default_factory=list,
+        alias="defaultReminders",
+    )
+    items: list[GoogleCalendarEventIngress] = Field(default_factory=list)
+    next_page_token: str | None = Field(default=None, alias="nextPageToken")
+    next_sync_token: str | None = Field(default=None, alias="nextSyncToken")
+
+    @field_validator("updated", mode="before")
+    @classmethod
+    def _coerce_response_updated(cls, value: object) -> object:
+        if not isinstance(value, str):
+            return value
+        return parse_utc_datetime_from_str(value)

plugin_google_calendar/models/translators.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from datetime import datetime, timezone
+from typing import Any
+
+from shared_plugins.models import IngressModel
+from shared_plugins.values import require_non_empty_text
+
+from .ctx import CalendarRow, EventRow
+from .ingress import (
+    EventDateTimeIngress,
+    GoogleCalendarCalendarListItemIngress,
+    GoogleCalendarEventIngress,
+)
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def calendars_to_ctx_models(
+    binding_id: str,
+    calendars: Iterable[GoogleCalendarCalendarListItemIngress],
+) -> Iterator[CalendarRow]:
+    for calendar in calendars:
+        yield CalendarRow(
+            ctx_binding_id=binding_id,
+            id=calendar.id,
+            etag=calendar.etag,
+            summary=calendar.summary,
+            summary_override=calendar.summary_override,
+            description=calendar.description,
+            location=calendar.location,
+            time_zone=calendar.time_zone,
+            access_role=calendar.access_role,
+            primary=calendar.primary,
+            selected=calendar.selected,
+            hidden=calendar.hidden,
+            is_deleted=calendar.deleted is True,
+            auto_accept_invitations=calendar.auto_accept_invitations,
+            data_owner=calendar.data_owner,
+            color_id=calendar.color_id,
+            background_color=calendar.background_color,
+            foreground_color=calendar.foreground_color,
+            default_reminders=_dump_model_list(calendar.default_reminders),
+            notification_settings=_dump_optional_model(calendar.notification_settings),
+            conference_properties=_dump_optional_model(calendar.conference_properties),
+        )
+
+
+def events_to_ctx_models(
+    binding_id: str,
+    calendar_id: str,
+    events: Iterable[GoogleCalendarEventIngress],
+) -> Iterator[EventRow]:
+    normalized_calendar_id = require_non_empty_text(
+        calendar_id,
+        label="calendar_id",
+        context="Google Calendar payload",
+    )
+
+    for event in events:
+        event_id = require_non_empty_text(
+            event.id,
+            label="id",
+            context="Google Calendar payload",
+        )
+        is_recurring_instance = event.recurring_event_id is not None
+        if is_recurring_instance and not _has_original_start(event.original_start_time):
+            raise RuntimeError(
+                "Google Calendar recurring instance is missing originalStartTime."
+            )
+
+        yield EventRow(
+            ctx_binding_id=binding_id,
+            ctx_source_updated_at=event.updated,
+            calendar_id=normalized_calendar_id,
+            id=event_id,
+            etag=event.etag,
+            status=event.status,
+            event_type=event.event_type,
+            is_cancelled=event.status == "cancelled",
+            is_all_day=event.start is not None and event.start.date is not None,
+            is_recurring_instance=is_recurring_instance,
+            i_cal_uid=event.i_cal_uid,
+            recurring_event_id=event.recurring_event_id,
+            sequence=event.sequence,
+            original_start_date=(
+                event.original_start_time.date if event.original_start_time else None
+            ),
+            original_start_date_time=(
+                event.original_start_time.date_time
+                if event.original_start_time
+                else None
+            ),
+            original_start_time_zone=(
+                event.original_start_time.time_zone
+                if event.original_start_time
+                else None
+            ),
+            summary=event.summary,
+            description=event.description,
+            location=event.location,
+            color_id=event.color_id,
+            html_link=event.html_link,
+            hangout_link=event.hangout_link,
+            creator_email=event.creator.email if event.creator else None,
+            creator_display_name=event.creator.display_name if event.creator else None,
+            creator_self=event.creator.is_self if event.creator else None,
+            organizer_email=event.organizer.email if event.organizer else None,
+            organizer_display_name=(
+                event.organizer.display_name if event.organizer else None
+            ),
+            organizer_self=event.organizer.is_self if event.organizer else None,
+            created_at=event.created,
+            updated_at=event.updated,
+            start_date=event.start.date if event.start else None,
+            start_date_time=event.start.date_time if event.start else None,
+            start_time_zone=event.start.time_zone if event.start else None,
+            end_date=event.end.date if event.end else None,
+            end_date_time=event.end.date_time if event.end else None,
+            end_time_zone=event.end.time_zone if event.end else None,
+            end_time_unspecified=event.end_time_unspecified,
+            transparency=event.transparency,
+            visibility=event.visibility,
+            locked=event.locked,
+            private_copy=event.private_copy,
+            attendees_omitted=event.attendees_omitted,
+            anyone_can_add_self=event.anyone_can_add_self,
+            guests_can_invite_others=event.guests_can_invite_others,
+            guests_can_modify=event.guests_can_modify,
+            guests_can_see_other_guests=event.guests_can_see_other_guests,
+            recurrence=list(event.recurrence) or None,
+            attendees=_dump_model_list(event.attendees),
+            attachments=_dump_model_list(event.attachments),
+            conference_data=_dump_optional_model(event.conference_data),
+            reminders=_dump_optional_model(event.reminders),
+            source=_dump_optional_model(event.source),
+            extended_properties_private=(
+                dict(event.extended_properties.private)
+                if event.extended_properties and event.extended_properties.private
+                else None
+            ),
+            extended_properties_shared=(
+                dict(event.extended_properties.shared)
+                if event.extended_properties and event.extended_properties.shared
+                else None
+            ),
+            out_of_office_properties=_dump_optional_model(
+                event.out_of_office_properties
+            ),
+            focus_time_properties=_dump_optional_model(event.focus_time_properties),
+            working_location_properties=_dump_optional_model(
+                event.working_location_properties
+            ),
+            birthday_properties=_dump_optional_model(event.birthday_properties),
+        )
+
+
+def _dump_optional_model(model: IngressModel | None) -> dict[str, Any] | None:
+    if model is None:
+        return None
+    dumped = model.model_dump(by_alias=True, exclude_none=True)
+    return dumped or None
+
+
+def _dump_model_list(models: Iterable[IngressModel]) -> list[dict[str, Any]] | None:
+    dumped = [model.model_dump(by_alias=True, exclude_none=True) for model in models]
+    return dumped or None
+
+
+def _has_original_start(value: EventDateTimeIngress | None) -> bool:
+    if value is None:
+        return False
+    return value.date is not None or value.date_time is not None

plugin_google_calendar/plugin.json

@@ -0,0 +1,9 @@
+{
+	"auth": {
+		"provider_id": "google",
+		"scopes": ["https://www.googleapis.com/auth/calendar.readonly"],
+		"type": "oauth"
+	},
+	"mode": "dagster",
+	"plugin_id": "google_calendar"
+}

plugin_google_calendar/sources/sync.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+import dlt
+from shared_plugins.exceptions import PluginCursorExpiredError
+from shared_plugins.google_client.http_errors import extract_http_status_code
+from shared_plugins.naming import (
+    dlt_resource_name,
+    dlt_source_name,
+    plugin_id_from_module,
+)
+from shared_plugins.resources import ctx_dlt_resource
+from shared_plugins.values import coerce_non_empty_string_mapping
+
+from ..models.ctx import CalendarRow, EventRow
+from ..models.translators import (
+    calendars_to_ctx_models,
+    events_to_ctx_models,
+    utc_now_iso,
+)
+from ..utils.client import GoogleCalendarApiClient
+
+ACTIVE_CALENDAR_IDS_KEY = "active_calendar_ids"
+EVENTS_SYNC_TOKENS_KEY = "events_sync_tokens"
+EVENTS_LAST_SYNCED_AT_KEY = "events_last_synced_at"
+PLUGIN_ID = plugin_id_from_module(__file__)
+JOB = "sync"
+FORCE_FULL_SYNC = False
+HARD_DELETE_ON_CANCELLED_EVENT = True
+LOGGER = logging.getLogger(__name__)
+
+
+def prune_events_sync_tokens(
+    active_calendar_ids: Iterable[str],
+    events_sync_tokens: Mapping[str, str],
+) -> dict[str, str]:
+    active_set = {
+        calendar_id.strip()
+        for calendar_id in active_calendar_ids
+        if calendar_id.strip()
+    }
+    return {
+        calendar_id: token
+        for calendar_id, token in events_sync_tokens.items()
+        if calendar_id in active_set and token
+    }
+
+
+def collect_calendar_snapshot(
+    *,
+    binding_id: str,
+    client: GoogleCalendarApiClient,
+) -> tuple[list[CalendarRow], list[str]]:
+    rows: list[CalendarRow] = []
+    active_calendar_ids: set[str] = set()
+    page_count = 0
+
+    for page in client.iter_calendar_list_pages():
+        page_count += 1
+        for row in calendars_to_ctx_models(binding_id, page.items):
+            rows.append(row)
+
+            if not row.is_deleted:
+                active_calendar_ids.add(row.id)
+
+    sorted_active = sorted(active_calendar_ids)
+    LOGGER.info(
+        "google_calendar.calendars.snapshot binding_id=%s total=%d active=%d deleted=%d pages=%d",
+        binding_id,
+        len(rows),
+        len(sorted_active),
+        len(rows) - len(sorted_active),
+        page_count,
+    )
+    return rows, sorted_active
+
+
+def iter_events_for_active_calendars(
+    *,
+    binding_id: str,
+    client: GoogleCalendarApiClient,
+    active_calendar_ids: Iterable[str],
+    events_sync_tokens: Mapping[str, str],
+    next_sync_tokens: dict[str, str],
+) -> Iterable[EventRow]:
+    sorted_ids = sorted(
+        {
+            calendar_id.strip()
+            for calendar_id in active_calendar_ids
+            if calendar_id.strip()
+        }
+    )
+    total_events = 0
+    calendars_synced = 0
+    calendars_skipped = 0
+    t0 = time.monotonic()
+
+    for calendar_idx, calendar_id in enumerate(sorted_ids, 1):
+        initial_sync_token = events_sync_tokens.get(calendar_id)
+        # Attempt plan per calendar:
+        # - existing token: incremental first, then full-sync fallback on stale cursor
+        # - no token: full sync only
+        attempt_tokens: tuple[str | None, ...] = (
+            (initial_sync_token, None) if initial_sync_token else (None,)
+        )
+        latest_sync_token = initial_sync_token
+        fell_back_from_stale_cursor = False
+        calendar_event_count = 0
+
+        sync_mode = "incremental" if initial_sync_token else "full"
+        LOGGER.info(
+            "google_calendar.events.calendar_start binding_id=%s calendar=%d/%d calendar_id=%s mode=%s",
+            binding_id,
+            calendar_idx,
+            len(sorted_ids),
+            calendar_id,
+            sync_mode,
+        )
+
+        try:
+            for attempt_sync_token in attempt_tokens:
+                latest_sync_token = attempt_sync_token
+                try:
+                    for page in client.iter_event_pages(
+                        calendar_id, sync_token=attempt_sync_token
+                    ):
+                        if page.next_sync_token:
+                            latest_sync_token = page.next_sync_token
+
+                        for row in events_to_ctx_models(
+                            binding_id, calendar_id, page.items
+                        ):
+                            calendar_event_count += 1
+                            total_events += 1
+                            yield row
+                    break
+                except PluginCursorExpiredError:
+                    if attempt_sync_token is None:
+                        raise
+                    LOGGER.info(
+                        "google_calendar.events.cursor_expired binding_id=%s calendar_id=%s fallback=full",
+                        binding_id,
+                        calendar_id,
+                    )
+                    fell_back_from_stale_cursor = True
+                    continue
+        except Exception as exc:
+            status_code = extract_http_status_code(exc)
+            LOGGER.warning(
+                "google_calendar.events.skip_calendar binding_id=%s calendar_id=%s status_code=%s reason=%s",
+                binding_id,
+                calendar_id,
+                status_code if status_code is not None else "-",
+                exc,
+            )
+            if initial_sync_token and not fell_back_from_stale_cursor:
+                next_sync_tokens[calendar_id] = initial_sync_token
+            calendars_skipped += 1
+            continue
+
+        calendars_synced += 1
+        LOGGER.info(
+            "google_calendar.events.calendar_done binding_id=%s calendar_id=%s events=%d",
+            binding_id,
+            calendar_id,
+            calendar_event_count,
+        )
+
+        if latest_sync_token:
+            next_sync_tokens[calendar_id] = latest_sync_token
+
+    elapsed = time.monotonic() - t0
+    LOGGER.info(
+        "google_calendar.events.complete binding_id=%s calendars_synced=%d calendars_skipped=%d total_events=%d elapsed=%.1fs",
+        binding_id,
+        calendars_synced,
+        calendars_skipped,
+        total_events,
+        elapsed,
+    )
+
+
+@dlt.source(name=dlt_source_name(PLUGIN_ID, JOB))
+def google_calendar_sync_source(
+    binding_id: str,
+    *,
+    client: GoogleCalendarApiClient,
+) -> tuple[Any, ...]:
+    calendars_cache: list[CalendarRow] | None = None
+    active_calendar_ids_cache: list[str] | None = None
+
+    def get_calendar_snapshot() -> tuple[list[CalendarRow], list[str]]:
+        nonlocal calendars_cache, active_calendar_ids_cache
+        if calendars_cache is None or active_calendar_ids_cache is None:
+            calendars_cache, active_calendar_ids_cache = collect_calendar_snapshot(
+                binding_id=binding_id,
+                client=client,
+            )
+        return calendars_cache, active_calendar_ids_cache
+
+    @ctx_dlt_resource(
+        name=dlt_resource_name("calendars"),
+        write_disposition="merge",
+        primary_key=("_ctx_binding_id", "id"),
+    )
+    def calendars_resource() -> Iterable[CalendarRow]:
+        rows, _ = get_calendar_snapshot()
+        for row in rows:
+            yield row
+
+    @ctx_dlt_resource(
+        name=dlt_resource_name("events"),
+        write_disposition="merge",
+        primary_key=("_ctx_binding_id", "calendar_id", "id"),
+        columns={"is_cancelled": {"hard_delete": HARD_DELETE_ON_CANCELLED_EVENT}},
+    )
+    def events_resource() -> Iterable[EventRow]:
+        source_state = dlt.current.source_state()
+        _, active_calendar_ids = get_calendar_snapshot()
+
+        if FORCE_FULL_SYNC:
+            sync_tokens_for_run: dict[str, str] = {}
+        else:
+            existing_sync_tokens = coerce_non_empty_string_mapping(
+                source_state.get(EVENTS_SYNC_TOKENS_KEY)
+            )
+            sync_tokens_for_run = prune_events_sync_tokens(
+                active_calendar_ids, existing_sync_tokens
+            )
+
+        next_sync_tokens: dict[str, str] = {}
+        yield from iter_events_for_active_calendars(
+            binding_id=binding_id,
+            client=client,
+            active_calendar_ids=active_calendar_ids,
+            events_sync_tokens=sync_tokens_for_run,
+            next_sync_tokens=next_sync_tokens,
+        )
+
+        source_state[ACTIVE_CALENDAR_IDS_KEY] = active_calendar_ids
+        source_state[EVENTS_SYNC_TOKENS_KEY] = next_sync_tokens
+        source_state[EVENTS_LAST_SYNCED_AT_KEY] = utc_now_iso()
+
+    return (calendars_resource, events_resource)

plugin_google_calendar/utils/client.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Iterator, TypeVar
+
+from googleapiclient.errors import HttpError
+
+from shared_plugins.exceptions import PluginConfigurationError, PluginCursorExpiredError
+from shared_plugins.google_client.http_errors import extract_http_status_code
+
+from shared_plugins.models import IngressModel
+
+from ..models.ingress import (
+    GoogleCalendarCalendarListResponseIngress,
+    GoogleCalendarEventsListResponseIngress,
+)
+
+ModelT = TypeVar("ModelT", bound=IngressModel)
+CALENDAR_LIST_MAX_RESULTS = 250
+EVENTS_LIST_MAX_RESULTS = 2500
+API_NUM_RETRIES = 5
+INCLUDE_HIDDEN_CALENDARS = False
+MIN_ACCESS_ROLE = "reader"
+SINGLE_EVENTS = True
+
+
+class GoogleCalendarApiClient:
+    def __init__(
+        self,
+        *,
+        service: Any,
+    ) -> None:
+        if service is None:
+            raise PluginConfigurationError(
+                "No Google Calendar service provided. Pass an authenticated service via service=..."
+            )
+
+        self._service = service
+
+    def _execute(self, request: Any) -> dict[str, Any]:
+        payload = request.execute(num_retries=API_NUM_RETRIES)
+        if not isinstance(payload, Mapping):
+            raise RuntimeError(
+                "Google Calendar API returned a non-object response payload."
+            )
+        return dict(payload)
+
+    def _execute_model(self, request: Any, model_type: type[ModelT]) -> ModelT:
+        payload = self._execute(request)
+        return model_type.model_validate(payload)
+
+    def iter_calendar_list_pages(
+        self,
+    ) -> Iterator[GoogleCalendarCalendarListResponseIngress]:
+        page_token: str | None = None
+
+        while True:
+            kwargs: dict[str, Any] = {
+                "maxResults": CALENDAR_LIST_MAX_RESULTS,
+                "showDeleted": True,
+                "showHidden": INCLUDE_HIDDEN_CALENDARS,
+                "minAccessRole": MIN_ACCESS_ROLE,
+            }
+            if page_token:
+                kwargs["pageToken"] = page_token
+
+            request = self._service.calendarList().list(**kwargs)
+            payload = self._execute_model(
+                request,
+                GoogleCalendarCalendarListResponseIngress,
+            )
+            yield payload
+
+            if not payload.next_page_token:
+                break
+            page_token = payload.next_page_token
+
+    def iter_event_pages(
+        self,
+        calendar_id: str,
+        *,
+        sync_token: str | None = None,
+    ) -> Iterator[GoogleCalendarEventsListResponseIngress]:
+        page_token: str | None = None
+
+        while True:
+            kwargs: dict[str, Any] = {
+                "calendarId": calendar_id,
+                "maxResults": EVENTS_LIST_MAX_RESULTS,
+                "showDeleted": True,
+                "singleEvents": SINGLE_EVENTS,
+            }
+            if sync_token:
+                kwargs["syncToken"] = sync_token
+            if page_token:
+                kwargs["pageToken"] = page_token
+
+            try:
+                request = self._service.events().list(**kwargs)
+                raw = self._execute(request)
+                payload = GoogleCalendarEventsListResponseIngress.model_validate(raw)
+            except HttpError as exc:
+                if extract_http_status_code(exc) == 410:
+                    raise PluginCursorExpiredError(
+                        "Google Calendar sync token is stale. Clear per-calendar token and rerun full sync."
+                    ) from exc
+                raise
+
+            yield payload
+
+            if not payload.next_page_token:
+                break
+            page_token = payload.next_page_token