Coverage for youversion/core/data_processor.py: 100%

1"""Data processor for YouVersion API responses.""" 

2 

3from datetime import datetime 

4from typing import Any 

5 

6from ..models import Moment, Reference, Votd 

7from ..utils import create_instance_from_response 

8from .interfaces import IDataProcessor 

9 

10 

11class DataProcessor(IDataProcessor): 

12 """Processes raw API responses into structured objects.""" 

13 

14 def __init__(self): 

15 """Initialize data processor.""" 

16 

17 def _create_references(self, references: list[dict[str, Any]]) -> list[Reference]: 

18 """Create Reference objects from raw data using dynamic creation. 

19 

20 Args: 

21 references: List of reference dictionaries 

22 

23 Returns: 

24 List of dynamically created Reference objects 

25 """ 

26 normalized: list[Reference] = [] 

27 for ref in references: 

28 usfm_value = ref.get("usfm") 

29 # Normalize usfm to a string when a single-item list is provided 

30 if isinstance(usfm_value, list) and len(usfm_value) == 1: 

31 usfm_value = usfm_value[0] 

32 ref_data = { 

33 "version_id": ref["version_id"], 

34 "human": ref["human"], 

35 "usfm": usfm_value, 

36 } 

37 reference = create_instance_from_response("Reference", ref_data) 

38 normalized.append(reference) 

39 return normalized 

40 

41 def _process_common_fields(self, obj: dict[str, Any]) -> dict[str, Any]: 

42 """Process common fields in moment objects using dynamic creation. 

43 

44 Args: 

45 obj: Raw object data 

46 

47 Returns: 

48 Processed object data 

49 """ 

50 # Process comments 

51 comments = obj.get("comments", {}) 

52 if comments: 

53 obj["comments"] = create_instance_from_response("Comment", comments) 

54 

55 # Process likes 

56 likes = obj.get("likes", {}) 

57 if likes: 

58 obj["likes"] = create_instance_from_response("Like", likes) 

59 

60 # Process user 

61 user = obj.get("user", {}) 

62 if user: 

63 obj["user"] = create_instance_from_response("User", user) 

64 

65 return obj 

66 

67 def process_moments(self, raw_data: list[dict[str, Any]]) -> list[Moment]: 

68 """Process raw moments data using dynamic Pydantic models. 

69 

70 Args: 

71 raw_data: Raw moments data from API 

72 

73 Returns: 

74 List of dynamically created Moment objects conforming to 

75 MomentProtocol 

76 """ 

77 moments = [] 

78 

79 for item in raw_data: 

80 # Create a dynamic dataclass instance from the moment item 

81 # Use kind_id to create a unique class name 

82 kind_id = item.get("kind_id", "moment") 

83 # Sanitize kind_id for class name 

84 kind_base = kind_id.split(".")[0] 

85 class_name = f"{kind_base.replace('.', '').replace('_', '').title()}" 

86 moment = create_instance_from_response(class_name, item) 

87 moments.append(moment) 

88 

89 return moments 

90 

91 def process_highlights(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

92 """Process raw highlights data using dynamic Pydantic models. 

93 

94 Args: 

95 raw_data: Raw highlights data from API 

96 

97 Returns: 

98 List of dynamically created Highlight objects 

99 """ 

100 highlights = [] 

101 

102 for item in raw_data: 

103 # Create a dynamic dataclass instance from the highlight item 

104 class_name = "Highlight" 

105 highlight = create_instance_from_response(class_name, item) 

106 highlights.append(highlight) 

107 

108 return highlights 

109 

110 def process_verse_of_the_day( 

111 self, raw_data: dict[str, Any], day: int | None = None 

112 ) -> Votd: 

113 """Process verse of the day data using dynamic creation. 

114 

115 Args: 

116 raw_data: Raw verse of the day data 

117 day: Specific day number (optional) 

118 

119 Returns: 

120 Dynamically created Votd object 

121 """ 

122 requested_day: int | None = day 

123 if day is None: 

124 day = datetime.now().timetuple().tm_yday 

125 

126 votd_data = raw_data.get("votd", []) 

127 for ref in votd_data: 

128 if ref["day"] == day: 

129 return create_instance_from_response("Votd", ref) 

130 

131 # Always fallback to first when available 

132 if votd_data: 

133 return create_instance_from_response("Votd", votd_data[0]) 

134 # No data at all 

135 day_value = requested_day if requested_day is not None else day 

136 raise ValueError(f"No verse of the day found for day {day_value}") 

137 

138 def process_notes(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

139 """Process raw notes data using dynamic Pydantic models. 

140 

141 Args: 

142 raw_data: Raw notes data from API 

143 

144 Returns: 

145 List of dynamically created Note objects 

146 """ 

147 notes = [] 

148 for item in raw_data: 

149 note = create_instance_from_response("Note", item) 

150 notes.append(note) 

151 return notes 

152 

153 def process_bookmarks(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

154 """Process raw bookmarks data using dynamic Pydantic models. 

155 

156 Args: 

157 raw_data: Raw bookmarks data from API 

158 

159 Returns: 

160 List of dynamically created Bookmark objects 

161 """ 

162 bookmarks = [] 

163 for item in raw_data: 

164 bookmark = create_instance_from_response("Bookmark", item) 

165 bookmarks.append(bookmark) 

166 return bookmarks 

167 

168 def process_images(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

169 """Process raw images data using dynamic Pydantic models. 

170 

171 Args: 

172 raw_data: Raw images data from API 

173 

174 Returns: 

175 List of dynamically created Image objects 

176 """ 

177 images = [] 

178 for item in raw_data: 

179 image = create_instance_from_response("Image", item) 

180 images.append(image) 

181 return images 

182 

183 def process_plan_progress(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

184 """Process raw plan progress data using dynamic Pydantic models. 

185 

186 Args: 

187 raw_data: Raw plan progress data from API 

188 

189 Returns: 

190 List of dynamically created PlanProgress objects 

191 """ 

192 plan_progress = [] 

193 for item in raw_data: 

194 progress = create_instance_from_response("PlanProgress", item) 

195 plan_progress.append(progress) 

196 return plan_progress 

197 

198 def process_plan_subscriptions(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

199 """Process raw plan subscriptions data using dynamic Pydantic models. 

200 

201 Args: 

202 raw_data: Raw plan subscriptions data from API 

203 

204 Returns: 

205 List of dynamically created PlanSubscription objects 

206 """ 

207 plan_subscriptions = [] 

208 for item in raw_data: 

209 subscription = create_instance_from_response("PlanSubscription", item) 

210 plan_subscriptions.append(subscription) 

211 return plan_subscriptions 

212 

213 def process_badges(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

214 """Process raw badges data using dynamic Pydantic models. 

215 

216 Args: 

217 raw_data: Raw badges data from API 

218 

219 Returns: 

220 List of dynamically created Badge objects 

221 """ 

222 badges = [] 

223 for item in raw_data: 

224 badge = create_instance_from_response("Badge", item) 

225 badges.append(badge) 

226 return badges 

227 

228 def process_plan_completions(self, raw_data: list[dict[str, Any]]) -> list[Any]: 

229 """Process raw plan completions data using dynamic Pydantic models. 

230 

231 Args: 

232 raw_data: Raw plan completions data from API 

233 

234 Returns: 

235 List of dynamically created PlanCompletion objects 

236 """ 

237 plan_completions = [] 

238 for item in raw_data: 

239 completion = create_instance_from_response("PlanCompletion", item) 

240 plan_completions.append(completion) 

241 return plan_completions 

242 

243 def process_search_bible(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

244 """Process raw Bible search results using dynamic Pydantic models. 

245 

246 Args: 

247 raw_data: Raw Bible search results data from API 

248 

249 Returns: 

250 Processed search results with dynamically created objects 

251 """ 

252 return create_instance_from_response("BibleSearch", raw_data) 

253 

254 def process_bible_chapter(self, raw_data: dict[str, Any]) -> Any: 

255 """Process raw Bible chapter data using dynamic Pydantic models. 

256 

257 Args: 

258 raw_data: Raw Bible chapter data from API 

259 

260 Returns: 

261 Dynamically created BibleChapter object 

262 """ 

263 return create_instance_from_response("BibleChapter", raw_data) 

264 

265 def process_bible_version(self, raw_data: dict[str, Any]) -> Any: 

266 """Process raw Bible version data using dynamic Pydantic models. 

267 

268 Args: 

269 raw_data: Raw Bible version data from API 

270 

271 Returns: 

272 Dynamically created Version object 

273 """ 

274 return create_instance_from_response("Version", raw_data) 

275 

276 def process_bible_versions(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

277 """Process raw Bible versions data using dynamic Pydantic models. 

278 

279 Args: 

280 raw_data: Raw Bible versions data from API 

281 

282 Returns: 

283 Processed versions data with dynamically created objects 

284 """ 

285 processed_data = raw_data.copy() 

286 

287 # Process versions list if it exists 

288 if "versions" in processed_data: 

289 versions = [] 

290 for item in processed_data["versions"]: 

291 version = create_instance_from_response("Version", item) 

292 versions.append(version) 

293 processed_data["versions"] = versions 

294 

295 # Create the main BibleVersions model 

296 return create_instance_from_response("BibleVersions", processed_data) 

297 

298 def process_audio_chapter( 

299 self, raw_data: dict[str, Any] | list[dict[str, Any]] 

300 ) -> Any: 

301 """Process raw audio chapter data using dynamic Pydantic models. 

302 

303 Args: 

304 raw_data: Raw audio chapter data from API (dict or list of dicts) 

305 

306 Returns: 

307 AudioChapter object or list of AudioChapter objects 

308 """ 

309 # Handle list input 

310 if isinstance(raw_data, list): 

311 chapters = [] 

312 for item in raw_data: 

313 chapter = create_instance_from_response("AudioChapter", item) 

314 chapters.append(chapter) 

315 return chapters 

316 # Handle dict input 

317 return create_instance_from_response("AudioChapter", raw_data) 

318 

319 def process_audio_version(self, raw_data: dict[str, Any]) -> Any: 

320 """Process raw audio version data using dynamic Pydantic models. 

321 

322 Args: 

323 raw_data: Raw audio version data from API 

324 

325 Returns: 

326 Dynamically created AudioVersion object 

327 """ 

328 return create_instance_from_response("AudioVersion", raw_data) 

329 

330 def process_send_friend_request(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

331 """Process raw friend request data using dynamic Pydantic models. 

332 

333 Args: 

334 raw_data: Raw friend request data from API 

335 

336 Returns: 

337 Processed friend request data with dynamically created objects 

338 """ 

339 return create_instance_from_response("FriendshipRequest", raw_data) 

340 

341 def process_bible_configuration(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

342 """Process raw Bible configuration data using dynamic Pydantic models. 

343 

344 Args: 

345 raw_data: Raw Bible configuration data from API 

346 

347 Returns: 

348 Processed configuration data with dynamically created objects 

349 """ 

350 return create_instance_from_response("BibleConfiguration", raw_data) 

351 

352 def process_recommended_languages(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

353 """Process recommended languages data using dynamic Pydantic models. 

354 

355 Args: 

356 raw_data: Raw recommended languages data from API 

357 

358 Returns: 

359 Processed languages data with dynamically created objects 

360 """ 

361 return create_instance_from_response("RecommendedLanguages", raw_data) 

362 

363 def process_search_plans(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

364 """Process raw plan search results using dynamic Pydantic models. 

365 

366 Args: 

367 raw_data: Raw plan search results data from API 

368 

369 Returns: 

370 Processed search results with dynamically created objects 

371 """ 

372 return create_instance_from_response("PlanSearch", raw_data) 

373 

374 def process_search_users(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

375 """Process raw user search results using dynamic Pydantic models. 

376 

377 Args: 

378 raw_data: Raw user search results data from API 

379 

380 Returns: 

381 Processed search results with dynamically created objects 

382 """ 

383 return create_instance_from_response("UserSearch", raw_data) 

384 

385 def process_videos(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

386 """Process raw videos data using dynamic Pydantic models. 

387 

388 Args: 

389 raw_data: Raw videos data from API 

390 

391 Returns: 

392 Processed videos data with dynamically created objects 

393 """ 

394 return create_instance_from_response("Videos", raw_data) 

395 

396 def process_video_details(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

397 """Process raw video details data using dynamic Pydantic models. 

398 

399 Args: 

400 raw_data: Raw video details data from API 

401 

402 Returns: 

403 Processed video details with dynamically created objects 

404 """ 

405 return create_instance_from_response("VideoDetails", raw_data) 

406 

407 def process_image_upload_url(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

408 """Process raw image upload URL data using dynamic Pydantic models. 

409 

410 Args: 

411 raw_data: Raw image upload URL data from API 

412 

413 Returns: 

414 Processed upload URL data with dynamically created objects 

415 """ 

416 return create_instance_from_response("ImageUploadUrl", raw_data) 

417 

418 def process_search_events(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

419 """Process raw event search results using dynamic Pydantic models. 

420 

421 Args: 

422 raw_data: Raw event search results data from API 

423 

424 Returns: 

425 Processed search results with dynamically created objects 

426 """ 

427 return create_instance_from_response("EventSearch", raw_data) 

428 

429 def process_event_details(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

430 """Process raw event details data using dynamic Pydantic models. 

431 

432 Args: 

433 raw_data: Raw event details data from API 

434 

435 Returns: 

436 Processed event details with dynamically created objects 

437 """ 

438 return create_instance_from_response("EventDetails", raw_data) 

439 

440 def process_saved_events(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

441 """Process raw saved events data using dynamic Pydantic models. 

442 

443 Args: 

444 raw_data: Raw saved events data from API 

445 

446 Returns: 

447 Processed saved events data with dynamically created objects 

448 """ 

449 return create_instance_from_response("SavedEvents", raw_data) 

450 

451 def process_moments_list(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

452 """Process raw moments list data using dynamic Pydantic models. 

453 

454 Args: 

455 raw_data: Raw moments list data from API 

456 

457 Returns: 

458 Processed moments list with dynamically created objects 

459 """ 

460 return create_instance_from_response("MomentsList", raw_data) 

461 

462 def process_moment_details(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

463 """Process raw moment details data using dynamic Pydantic models. 

464 

465 Args: 

466 raw_data: Raw moment details data from API 

467 

468 Returns: 

469 Processed moment details with dynamically created objects 

470 """ 

471 return create_instance_from_response("MomentDetails", raw_data) 

472 

473 def process_moment_colors(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

474 """Process raw moment colors data using dynamic Pydantic models. 

475 

476 Args: 

477 raw_data: Raw moment colors data from API 

478 

479 Returns: 

480 Processed colors data with dynamically created objects 

481 """ 

482 if isinstance(raw_data, list): 

483 raw_data = {"colors": raw_data} 

484 return create_instance_from_response("MomentColors", raw_data) 

485 

486 def process_moment_labels(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

487 """Process raw moment labels data using dynamic Pydantic models. 

488 

489 Args: 

490 raw_data: Raw moment labels data from API 

491 

492 Returns: 

493 Processed labels data with dynamically created objects 

494 """ 

495 if isinstance(raw_data, list): 

496 raw_data = {"labels": raw_data} 

497 return create_instance_from_response("MomentLabels", raw_data) 

498 

499 def process_verse_colors(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

500 """Process raw verse colors data using dynamic Pydantic models. 

501 

502 Args: 

503 raw_data: Raw verse colors data from API 

504 

505 Returns: 

506 Processed verse colors data with dynamically created objects 

507 """ 

508 return create_instance_from_response("VerseColors", raw_data) 

509 

510 def process_moments_configuration(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

511 """Process moments configuration data using dynamic Pydantic models. 

512 

513 Args: 

514 raw_data: Raw moments configuration data from API 

515 

516 Returns: 

517 Processed configuration data with dynamically created objects 

518 """ 

519 return create_instance_from_response("MomentsConfiguration", raw_data) 

520 

521 def process_themes(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

522 """Process raw themes data using dynamic Pydantic models. 

523 

524 Args: 

525 raw_data: Raw themes data from API 

526 

527 Returns: 

528 Processed themes data with dynamically created objects 

529 """ 

530 return create_instance_from_response("Themes", raw_data) 

531 

532 def process_theme_description(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

533 """Process raw theme description data using dynamic Pydantic models. 

534 

535 Args: 

536 raw_data: Raw theme description data from API 

537 

538 Returns: 

539 Processed theme description with dynamically created objects 

540 """ 

541 return create_instance_from_response("ThemeDescription", raw_data) 

542 

543 def process_event_configuration(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

544 """Process raw event configuration data using dynamic Pydantic models. 

545 

546 Args: 

547 raw_data: Raw event configuration data from API 

548 

549 Returns: 

550 Processed configuration data with dynamically created objects 

551 """ 

552 return create_instance_from_response("EventConfiguration", raw_data) 

553 

554 def process_all_saved_event_ids(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

555 """Process raw all saved event IDs data using dynamic Pydantic models. 

556 

557 Args: 

558 raw_data: Raw all saved event IDs data from API 

559 

560 Returns: 

561 Processed event IDs data with dynamically created objects 

562 """ 

563 return create_instance_from_response("AllSavedEventIds", raw_data) 

564 

565 def process_save_event(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

566 """Process raw save event response using dynamic Pydantic models. 

567 

568 Args: 

569 raw_data: Raw save event response data from API 

570 

571 Returns: 

572 Processed save event response with dynamically created objects 

573 """ 

574 return create_instance_from_response("SaveEvent", raw_data) 

575 

576 def process_delete_saved_event(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

577 """Process raw delete saved event response using dynamic Pydantic models. 

578 

579 Args: 

580 raw_data: Raw delete saved event response data from API 

581 

582 Returns: 

583 Processed delete response with dynamically created objects 

584 """ 

585 return create_instance_from_response("DeleteSavedEvent", raw_data) 

586 

587 def process_create_moment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

588 """Process raw create moment response using dynamic Pydantic models. 

589 

590 Args: 

591 raw_data: Raw create moment response data from API 

592 

593 Returns: 

594 Processed create moment response with dynamically created objects 

595 """ 

596 return create_instance_from_response("CreateMomentResponse", raw_data) 

597 

598 def process_update_moment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

599 """Process raw update moment response using dynamic Pydantic models. 

600 

601 Args: 

602 raw_data: Raw update moment response data from API 

603 

604 Returns: 

605 Processed update moment response with dynamically created objects 

606 """ 

607 return create_instance_from_response("UpdateMomentResponse", raw_data) 

608 

609 def process_delete_moment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

610 """Process raw delete moment response using dynamic Pydantic models. 

611 

612 Args: 

613 raw_data: Raw delete moment response data from API 

614 

615 Returns: 

616 Processed delete moment response with dynamically created objects 

617 """ 

618 return create_instance_from_response("DeleteMomentResponse", raw_data) 

619 

620 def process_hide_verse_colors(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

621 """Process raw hide verse colors response using dynamic Pydantic models. 

622 

623 Args: 

624 raw_data: Raw hide verse colors response data from API 

625 

626 Returns: 

627 Processed hide verse colors response with dynamically created objects 

628 """ 

629 return create_instance_from_response("HideVerseColors", raw_data) 

630 

631 def process_create_comment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

632 """Process raw create comment response using dynamic Pydantic models. 

633 

634 Args: 

635 raw_data: Raw create comment response data from API 

636 

637 Returns: 

638 Processed create comment response with dynamically created objects 

639 """ 

640 return create_instance_from_response("CreateComment", raw_data) 

641 

642 def process_delete_comment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

643 """Process raw delete comment response using dynamic Pydantic models. 

644 

645 Args: 

646 raw_data: Raw delete comment response data from API 

647 

648 Returns: 

649 Processed delete comment response with dynamically created objects 

650 """ 

651 return create_instance_from_response("DeleteComment", raw_data) 

652 

653 def process_like_moment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

654 """Process raw like moment response using dynamic Pydantic models. 

655 

656 Args: 

657 raw_data: Raw like moment response data from API 

658 

659 Returns: 

660 Processed like moment response with dynamically created objects 

661 """ 

662 return create_instance_from_response("LikeMoment", raw_data) 

663 

664 def process_unlike_moment(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

665 """Process raw unlike moment response using dynamic Pydantic models. 

666 

667 Args: 

668 raw_data: Raw unlike moment response data from API 

669 

670 Returns: 

671 Processed unlike moment response with dynamically created objects 

672 """ 

673 return create_instance_from_response("UnlikeMoment", raw_data) 

674 

675 def process_register_device(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

676 """Process raw register device response using dynamic Pydantic models. 

677 

678 Args: 

679 raw_data: Raw register device response data from API 

680 

681 Returns: 

682 Processed register device response with dynamically created objects 

683 """ 

684 return create_instance_from_response("RegisterDevice", raw_data) 

685 

686 def process_unregister_device(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

687 """Process raw unregister device response using dynamic Pydantic models. 

688 

689 Args: 

690 raw_data: Raw unregister device response data from API 

691 

692 Returns: 

693 Processed unregister device response with dynamically created objects 

694 """ 

695 return create_instance_from_response("UnregisterDevice", raw_data) 

696 

697 def process_add_theme(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

698 """Process raw add theme response using dynamic Pydantic models. 

699 

700 Args: 

701 raw_data: Raw add theme response data from API 

702 

703 Returns: 

704 Processed add theme response with dynamically created objects 

705 """ 

706 return create_instance_from_response("AddTheme", raw_data) 

707 

708 def process_remove_theme(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

709 """Process raw remove theme response using dynamic Pydantic models. 

710 

711 Args: 

712 raw_data: Raw remove theme response data from API 

713 

714 Returns: 

715 Processed remove theme response with dynamically created objects 

716 """ 

717 return create_instance_from_response("RemoveTheme", raw_data) 

718 

719 def process_set_theme(self, raw_data: dict[str, Any]) -> dict[str, Any]: 

720 """Process raw set theme response using dynamic Pydantic models. 

721 

722 Args: 

723 raw_data: Raw set theme response data from API 

724 

725 Returns: 

726 Processed set theme response with dynamically created objects 

727 """ 

728 return create_instance_from_response("SetTheme", raw_data)