models.py 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215
  1. """Normalized models for the Teams meeting pipeline plugin."""
  2. from __future__ import annotations
  3. from dataclasses import dataclass, field, fields
  4. from datetime import datetime, timezone, UTC
  5. from typing import Any, Callable, ClassVar, Literal
  6. ArtifactType = Literal["transcript", "recording", "call_record"]
  7. def _parse_datetime(value: Any) -> datetime | None:
  8. """Parse ISO-8601 (``Z`` accepted); naive values are assumed UTC, aware values keep their offset."""
  9. if value is None or isinstance(value, datetime):
  10. return value
  11. text = str(value).strip()
  12. if not text:
  13. return None
  14. if text.endswith("Z"):
  15. text = f"{text[:-1]}+00:00"
  16. parsed = datetime.fromisoformat(text)
  17. return parsed.replace(tzinfo=UTC) if parsed.tzinfo is None else parsed
  18. def _serialize_datetime(value: datetime | None) -> str | None:
  19. return None if value is None else value.astimezone(UTC).isoformat().replace("+00:00", "Z")
  20. def _camel(name: str) -> str:
  21. head, *rest = name.split("_")
  22. return head + "".join(part.title() for part in rest)
  23. def _pick(payload: dict[str, Any], *keys: str) -> Any:
  24. """``payload.get(k1) or payload.get(k2) or ...`` (returns the last value when all are falsy)."""
  25. return next((payload.get(key) for key in keys if payload.get(key)), payload.get(keys[-1]))
  26. _str = lambda value: str(value or "").strip()
  27. _list = lambda value: list(value or [])
  28. _dict = lambda value: dict(value or {})
  29. _nested = lambda model: (lambda value: model.from_dict(value) if value else None)
  30. def _serialize_value(value: Any) -> Any:
  31. """Datetimes -> ISO Z; nested models -> dicts; empty lists/dicts -> None (dropped by ``to_dict``)."""
  32. if isinstance(value, datetime):
  33. return _serialize_datetime(value)
  34. if isinstance(value, list):
  35. return [item.to_dict() if isinstance(item, _Model) else item for item in value] or None
  36. if isinstance(value, dict):
  37. return value or None
  38. return value.to_dict() if isinstance(value, _Model) else value
  39. class _Model:
  40. """Shared snake/camelCase ``from_dict`` and None-dropping ``to_dict``. ``_ALIASES`` overrides the default
  41. ``(snake_name, camelName)`` lookup keys; ``_CONVERT`` post-processes the picked value; ``_REQUIRED`` string
  42. fields must be non-blank; ``_DATETIMES`` are parsed in place."""
  43. _ALIASES: ClassVar[dict[str, tuple[str, ...]]] = {}
  44. _CONVERT: ClassVar[dict[str, Callable[[Any], Any]]] = {}
  45. _REQUIRED: ClassVar[tuple[str, ...]] = ()
  46. _DATETIMES: ClassVar[tuple[str, ...]] = ()
  47. @classmethod
  48. def from_dict(cls, payload: dict[str, Any]):
  49. return cls(**{
  50. spec.name: cls._CONVERT.get(spec.name, lambda v: v)(_pick(payload, *cls._ALIASES.get(spec.name, (spec.name, _camel(spec.name)))))
  51. for spec in fields(cls)
  52. })
  53. def to_dict(self) -> dict[str, Any]:
  54. out = {spec.name: _serialize_value(getattr(self, spec.name)) for spec in fields(self)}
  55. return {key: value for key, value in out.items() if value is not None}
  56. def __post_init__(self) -> None:
  57. for name in self._REQUIRED:
  58. if not getattr(self, name).strip():
  59. raise ValueError(f"{type(self).__name__}.{name} is required.")
  60. for name in self._DATETIMES:
  61. setattr(self, name, _parse_datetime(getattr(self, name)))
  62. @dataclass
  63. class GraphSubscription(_Model):
  64. subscription_id: str
  65. resource: str
  66. change_type: str
  67. notification_url: str
  68. expiration_datetime: datetime
  69. client_state: str | None = None
  70. latest_renewal_at: datetime | None = None
  71. status: str | None = None
  72. _ALIASES = {"subscription_id": ("subscription_id", "id"), "expiration_datetime": ("expiration_datetime", "expirationDateTime")}
  73. _REQUIRED = ("subscription_id", "resource", "change_type", "notification_url")
  74. _CONVERT = dict.fromkeys(_REQUIRED, _str)
  75. _DATETIMES = ("expiration_datetime", "latest_renewal_at")
  76. def __post_init__(self) -> None:
  77. super().__post_init__()
  78. if self.expiration_datetime is None:
  79. raise ValueError("GraphSubscription.expiration_datetime is required.")
  80. @dataclass
  81. class TeamsMeetingRef(_Model):
  82. meeting_id: str
  83. organizer_user_id: str | None = None
  84. join_web_url: str | None = None
  85. calendar_event_id: str | None = None
  86. thread_id: str | None = None
  87. tenant_id: str | None = None
  88. metadata: dict[str, Any] = field(default_factory=dict)
  89. _ALIASES = {"meeting_id": ("meeting_id", "id")}
  90. _CONVERT = {"meeting_id": _str, "metadata": _dict}
  91. _REQUIRED = ("meeting_id",)
  92. @dataclass
  93. class MeetingArtifact(_Model):
  94. artifact_type: ArtifactType
  95. artifact_id: str
  96. display_name: str | None = None
  97. content_type: str | None = None
  98. source_url: str | None = None
  99. download_url: str | None = None
  100. created_at: datetime | None = None
  101. available_at: datetime | None = None
  102. size_bytes: int | None = None
  103. metadata: dict[str, Any] = field(default_factory=dict)
  104. _ALIASES = {
  105. "artifact_id": ("artifact_id", "id"), "display_name": ("display_name", "displayName", "name"),
  106. "source_url": ("source_url", "sourceUrl", "webUrl"), "download_url": ("download_url", "downloadUrl", "@microsoft.graph.downloadUrl"),
  107. "created_at": ("created_at", "createdDateTime"), "available_at": ("available_at", "availableDateTime", "lastModifiedDateTime"),
  108. "size_bytes": ("size_bytes", "size"),
  109. }
  110. _CONVERT = {"artifact_id": _str, "metadata": _dict}
  111. _REQUIRED = ("artifact_id",)
  112. _DATETIMES = ("created_at", "available_at")
  113. def __post_init__(self) -> None:
  114. if self.artifact_type not in {"transcript", "recording", "call_record"}:
  115. raise ValueError("MeetingArtifact.artifact_type must be transcript, recording, or call_record.")
  116. super().__post_init__()
  117. if self.size_bytes is not None:
  118. self.size_bytes = int(self.size_bytes)
  119. @dataclass
  120. class TeamsMeetingSummaryPayload(_Model):
  121. meeting_ref: TeamsMeetingRef
  122. title: str | None = None
  123. start_time: datetime | None = None
  124. end_time: datetime | None = None
  125. participants: list[str] = field(default_factory=list)
  126. transcript_text: str | None = None
  127. summary: str | None = None
  128. key_decisions: list[str] = field(default_factory=list)
  129. action_items: list[str] = field(default_factory=list)
  130. risks: list[str] = field(default_factory=list)
  131. call_metrics: dict[str, Any] = field(default_factory=dict)
  132. source_artifacts: list[MeetingArtifact] = field(default_factory=list)
  133. confidence: str | None = None
  134. confidence_notes: str | None = None
  135. notion_target: str | None = None
  136. linear_target: str | None = None
  137. teams_target: str | None = None
  138. # Nested payloads are only read from their snake_case keys.
  139. _ALIASES = {"meeting_ref": ("meeting_ref",), "source_artifacts": ("source_artifacts",)}
  140. _CONVERT = {
  141. **dict.fromkeys(("participants", "key_decisions", "action_items", "risks"), _list), "call_metrics": _dict,
  142. "meeting_ref": TeamsMeetingRef.from_dict, "source_artifacts": lambda value: [MeetingArtifact.from_dict(item) for item in value or []],
  143. }
  144. _DATETIMES = ("start_time", "end_time")
  145. @classmethod
  146. def from_dict(cls, payload: dict[str, Any]) -> TeamsMeetingSummaryPayload:
  147. # meeting_ref is mandatory: a missing key raises KeyError rather than building a half-empty payload.
  148. return super().from_dict({**payload, "meeting_ref": payload["meeting_ref"]})
  149. @dataclass
  150. class TeamsMeetingPipelineJob(_Model):
  151. job_id: str
  152. event_id: str
  153. source_event_type: str
  154. dedupe_key: str
  155. status: str
  156. retry_count: int = 0
  157. created_at: datetime | None = None
  158. updated_at: datetime | None = None
  159. meeting_ref: TeamsMeetingRef | None = None
  160. selected_artifact_strategy: str | None = None
  161. summary_payload: TeamsMeetingSummaryPayload | None = None
  162. error_info: dict[str, Any] = field(default_factory=dict)
  163. _REQUIRED = ("job_id", "event_id", "source_event_type", "dedupe_key", "status")
  164. _CONVERT = {
  165. **dict.fromkeys(_REQUIRED, _str), "retry_count": lambda value: value or 0, "error_info": _dict,
  166. "meeting_ref": _nested(TeamsMeetingRef), "summary_payload": _nested(TeamsMeetingSummaryPayload),
  167. }
  168. _DATETIMES = ("created_at", "updated_at")
  169. def __post_init__(self) -> None:
  170. super().__post_init__()
  171. self.retry_count = int(self.retry_count)
  172. __all__ = ["ArtifactType", "GraphSubscription", "MeetingArtifact", "TeamsMeetingPipelineJob", "TeamsMeetingRef", "TeamsMeetingSummaryPayload"]