from __future__ import annotations from typing import Any, Mapping CAMERA_DIRECTIONS = ( "front-right quarter view", "right side view", "back-right quarter view", "back view", "back-left quarter view", "left side view", "front-left quarter view", "front view", ) CAMERA_ELEVATIONS = ("low-angle shot", "eye-level shot", "elevated shot", "high-angle shot") CAMERA_DISTANCES = ( "wide shot", "full-body shot", "three-quarter body shot", "medium shot", "close-up", "extreme close-up", ) SCENE_CAMERA_PROFILES: tuple[dict[str, Any], ...] = ( { "key": "business_cafe", "family": "coworking", "terms": ("business cafe", "work cafe", "cafe"), "layout_label": "Business cafe camera layout", "place": "business cafe coworking counter", "foreground": "counter edge, laptop corner, and small plant", "midground": "bar stools, warm desk lamps, and coffee-counter work spots", "background": "plants, mirror strip, menu wall, and repeated cafe work tables", "detail_label": "cafe details", "composition": { "woman": "business-cafe selfie frame with the woman near a counter edge and warm work-table depth behind her", "man": "business-cafe portrait frame with the man near a counter edge and warm work-table depth behind him", "default": "business-cafe frame with the subjects near a counter edge and warm work-table depth behind them", }, }, { "key": "office_after_hours", "family": "coworking", "terms": ("corporate office", "office after hours", "copier", "office lounge"), "layout_label": "Office camera layout", "place": "empty after-hours office", "foreground": "copier alcove edge, chair backs, and nearest desk corner", "midground": "repeating desks, glass partition seams, and muted monitor glow", "background": "rows of empty workstations, city-light windows, and quiet office depth", "detail_label": "office details", "composition": { "woman": "after-hours office frame with the woman near a desk edge and glass-partition depth behind her", "man": "after-hours office frame with the man near a desk edge and glass-partition depth behind him", "default": "after-hours office frame with the subjects near a desk edge and glass-partition depth behind them", }, }, { "key": "coworking_lounge", "family": "coworking", "terms": ( "coworking", "cowork", "shared office", "laptops", "warm desks", "repeating desks", "glass partitions", ), "layout_label": "Coworking camera layout", "place": "coworking lounge", "foreground": "near desk edge, laptop corner, and chair back", "midground": "warm work desks, laptop tables, and glass partition seams", "background": "tall windows, repeated desk rows, plants, and soft shared-office depth", "detail_label": "coworking details", "composition": { "woman": "coworking lounge selfie frame with the woman near a desk edge and tall-window depth behind her", "man": "coworking lounge portrait frame with the man near a desk edge and tall-window depth behind him", "default": "coworking lounge frame with the subjects near a desk edge and tall-window depth behind them", }, }, { "key": "classical_library", "family": "library", "terms": ( "classical library", "library stacks", "large library", "grand library", "reading room", "bookshelves", "book shelves", "book stacks", "rare-books", "rare books", "rolling ladders", ), "layout_label": "Library camera layout", "place": "classical library", "foreground": "near bookshelf edge, reading-table corner, and brass lamp", "midground": "towering bookshelves, rolling ladders, carved columns, and marble floor lines", "background": "arched windows, repeated book aisles, warm brass lamps, and deep quiet library depth", "detail_label": "library details", "composition": { "woman": "classical library frame with the woman near a bookshelf edge and long shelf depth behind her", "man": "classical library frame with the man near a bookshelf edge and long shelf depth behind him", "default": "classical library frame with the subjects near a bookshelf edge and long shelf depth behind them", }, }, ) SCENE_CAMERA_PROFILE_KEYS = {str(profile["key"]): dict(profile) for profile in SCENE_CAMERA_PROFILES} THEME_PROFILE_KEYS = { "classical_library": "classical_library", } MISMATCHED_COMPOSITION_TERMS = ( "outfit-check", "outfit check", "mirror view", "mirror pose", "bag", "shoes", "footwear", ) def _profile_by_key(value: Any) -> dict[str, Any]: key = str(value or "").strip() if not key: return {} if key in SCENE_CAMERA_PROFILE_KEYS: return dict(SCENE_CAMERA_PROFILE_KEYS[key]) mapped_key = THEME_PROFILE_KEYS.get(key) if mapped_key and mapped_key in SCENE_CAMERA_PROFILE_KEYS: return dict(SCENE_CAMERA_PROFILE_KEYS[mapped_key]) return {} def _scene_entry_text(scene_entry: Any) -> str: if not isinstance(scene_entry, dict): return "" return str( scene_entry.get("prompt") or scene_entry.get("description") or scene_entry.get("text") or scene_entry.get("name") or "" ).strip() def _scene_entry_profile_key(scene_entry: Any) -> str: if not isinstance(scene_entry, dict): return "" return str( scene_entry.get("scene_camera_profile_key") or scene_entry.get("camera_profile_key") or scene_entry.get("camera_profile") or scene_entry.get("profile") or "" ).strip() def scene_camera_profile( scene_text: Any = "", *, scene_entry: Any = None, theme: Any = "", profile_key: Any = "", ) -> dict[str, Any]: explicit_profile = _profile_by_key(profile_key) if explicit_profile: return explicit_profile entry_profile = _profile_by_key(_scene_entry_profile_key(scene_entry)) if entry_profile: return entry_profile theme_profile = _profile_by_key(theme) if theme_profile: return theme_profile if isinstance(scene_entry, dict): entry_theme_profile = _profile_by_key(scene_entry.get("theme")) if entry_theme_profile: return entry_theme_profile text = " ".join(part for part in (str(scene_text or ""), _scene_entry_text(scene_entry)) if part).lower() if not text: return {} for profile in SCENE_CAMERA_PROFILES: if any(term in text for term in profile["terms"]): return dict(profile) return {} def is_coworking_scene(scene_text: Any) -> bool: return scene_camera_profile(scene_text).get("family") == "coworking" def is_scene_camera_aware(scene_text: Any) -> bool: return bool(scene_camera_profile(scene_text)) def _compact_label(value: Any, compact_labels: Mapping[str, str] | None = None) -> str: text = str(value or "") if compact_labels and text in compact_labels: return compact_labels[text] return text.replace("_", " ") def camera_geometry_phrase(parsed: dict[str, Any], compact_labels: Mapping[str, str] | None = None) -> str: direction = str(parsed.get("orbit_direction") or "").strip() elevation = str(parsed.get("orbit_elevation_label") or "").strip() distance = str(parsed.get("orbit_distance_label") or "").strip() custom = str(parsed.get("custom_camera_prompt") or "").strip() if not any((direction, elevation, distance)) and custom: return custom parts = [part for part in (direction, elevation, distance) if part and part != "auto"] if parts: return ", ".join(parts) compact_parts = [ _compact_label(parsed.get(key), compact_labels) for key in ("shot_size", "angle", "distance") ] compact_parts = [part for part in compact_parts if part and part != "auto"] return ", ".join(compact_parts) def camera_direction_from_text(text: Any) -> str: source = str(text or "").lower() for label in CAMERA_DIRECTIONS: if label in source: return label return "" def camera_elevation_from_text(text: Any) -> str: source = str(text or "").lower() for label in CAMERA_ELEVATIONS: if label in source: return label return "" def camera_distance_from_text(text: Any) -> str: source = str(text or "").lower() for label in CAMERA_DISTANCES: if label in source: return label return "" def coworking_location_profile(scene_text: Any) -> dict[str, str]: profile = scene_camera_profile(scene_text) if profile.get("family") == "coworking": return profile return scene_camera_profile("coworking lounge") def coworking_subject_terms(subject_kind: str, pov_labels: list[str] | None = None) -> tuple[str, str]: if pov_labels: return "the visible partner", "them" if subject_kind == "woman": return "the woman", "her" if subject_kind == "man": return "the man", "him" if subject_kind == "couple": return "the couple", "them" return "the subjects", "them" def scene_direction_detail( direction: str, profile: dict[str, str], pov_labels: list[str] | None = None, subject_kind: str = "subjects", ) -> str: direction = str(direction or "").strip().lower() foreground = profile["foreground"] midground = profile["midground"] background = profile["background"] detail_label = profile.get("detail_label") or "location details" subject, pronoun = coworking_subject_terms(subject_kind, pov_labels) if pov_labels: if "right side" in direction: return f"{subject} is in right-side profile; {midground} run behind {pronoun} toward {background}, with {detail_label} kept at the frame edges" if "left side" in direction: return f"{subject} is in left-side profile; {midground} run behind {pronoun} toward {background}, with {detail_label} kept at the frame edges" if "back-right" in direction or "back-left" in direction: return f"{subject} stays close in one continuous diagonal first-person body angle; {midground} lead toward {background} behind {pronoun} at the edges, not in the lower foreground" if direction == "back view": return f"the viewer looks past {subject}'s back toward {midground}, then into {background}; only POV body cues sit low in frame" if "front-right" in direction or "front-left" in direction: return f"{subject} fills the first-person front-quarter view; {midground} recede diagonally behind {pronoun} toward {background}" return f"{subject} faces the viewer in first-person view; {midground} and {background} stay behind {pronoun}, not between viewer and body" if "right side" in direction or "left side" in direction: return f"{subject} is held in side profile along the {foreground}; {midground} run laterally behind {pronoun}, with {background} still readable" if "back-right" in direction or "back-left" in direction: return f"{subject} is viewed from a rear-quarter angle, partly turning back toward camera; the {foreground} stays low in frame while {midground} lead into {background}" if direction == "back view": return f"{subject} is seen from behind with the {foreground} at camera side, facing into {midground} and {background}" if "front-right" in direction or "front-left" in direction: return f"{subject} is placed beside the {foreground}; {midground} recede diagonally behind {pronoun} toward {background}" return f"{subject} faces camera beside the {foreground}; {midground} sit between {pronoun} and {background}" def coworking_direction_detail( direction: str, profile: dict[str, str], pov_labels: list[str] | None = None, subject_kind: str = "subjects", ) -> str: return scene_direction_detail(direction, profile, pov_labels, subject_kind) def scene_distance_detail( distance: str, profile: dict[str, str], subject_kind: str, pov_labels: list[str] | None = None, ) -> str: distance = str(distance or "").strip().lower() subject, _pronoun = coworking_subject_terms(subject_kind, pov_labels) if pov_labels: if "wide" in distance or "full-body" in distance or "full body" in distance: return f"wide POV keeps {subject} readable with {profile['place']} context behind them" if "close" in distance: return f"close POV keeps {subject} dominant with {profile['place']} context only at the sides or background" return f"medium POV keeps {subject} dominant with room context behind them" if "wide" in distance or "full-body" in distance or "full body" in distance: return f"wide crop keeps the {profile['foreground']}, {profile['midground']}, and {profile['background']} readable" if "close" in distance: return f"close crop keeps one anchor from the {profile['foreground']} visible" return f"medium crop keeps {subject} dominant" def coworking_distance_detail( distance: str, profile: dict[str, str], subject_kind: str, pov_labels: list[str] | None = None, ) -> str: return scene_distance_detail(distance, profile, subject_kind, pov_labels) def scene_elevation_detail( elevation: str, profile: dict[str, str], subject_kind: str, pov_labels: list[str] | None = None, ) -> str: elevation = str(elevation or "").strip().lower() subject, pronoun = coworking_subject_terms(subject_kind, pov_labels) if pov_labels: if "low-angle" in elevation: return f"low angle keeps POV body cues low while the {profile['background']} rises behind {pronoun}" if "elevated" in elevation: return f"elevated POV keeps the viewer's eye line slightly higher than {subject}, with {profile['foreground']} only behind or at the side edges" if "high-angle" in elevation: return f"high angle looks down from the viewer's position with {profile['midground']} only in the background" return f"eye-level angle keeps {profile['midground']} behind {pronoun}" if "low-angle" in elevation: return f"low angle keeps the {profile['foreground']} low while {profile['background']} rises behind {pronoun}" if "elevated" in elevation: return f"elevated angle shows the {profile['foreground']} and {profile['midground']} around {pronoun}" if "high-angle" in elevation: return f"high angle shows the {profile['place']} layout and placement of {pronoun}" return f"eye-level angle keeps {profile['midground']} visually stable" def coworking_elevation_detail( elevation: str, profile: dict[str, str], subject_kind: str, pov_labels: list[str] | None = None, ) -> str: return scene_elevation_detail(elevation, profile, subject_kind, pov_labels) def scene_camera_directive( scene_text: Any, parsed: dict[str, Any], pov_labels: list[str] | None = None, subject_kind: str = "subjects", compact_labels: Mapping[str, str] | None = None, *, scene_entry: Any = None, theme: Any = "", profile_key: Any = "", ) -> str: profile = scene_camera_profile(scene_text, scene_entry=scene_entry, theme=theme, profile_key=profile_key) if not profile: return "" direction = str(parsed.get("orbit_direction") or "").strip() elevation = str(parsed.get("orbit_elevation_label") or "").strip() distance = str(parsed.get("orbit_distance_label") or "").strip() custom_prompt = str(parsed.get("custom_camera_prompt") or "").strip() direction = direction or camera_direction_from_text(custom_prompt) elevation = elevation or camera_elevation_from_text(custom_prompt) distance = distance or camera_distance_from_text(custom_prompt) if not any((direction, elevation, distance, custom_prompt)): return "" direction_detail = scene_direction_detail(direction, profile, pov_labels, subject_kind) distance_detail = scene_distance_detail(distance, profile, subject_kind, pov_labels) elevation_detail = scene_elevation_detail(elevation, profile, subject_kind, pov_labels) if pov_labels: return ( f"{profile['layout_label']} from POV: {direction_detail}. " f"{distance_detail}; {elevation_detail}; use the multiangle camera only as first-person spatial geometry." ) geometry = camera_geometry_phrase(parsed, compact_labels) geometry_clause = f" ({geometry})" if geometry else "" return ( f"{profile['layout_label']}{geometry_clause}: {direction_detail}; " f"{distance_detail}; {elevation_detail}." ) def coworking_camera_scene_directive( scene_text: Any, parsed: dict[str, Any], pov_labels: list[str] | None = None, subject_kind: str = "subjects", compact_labels: Mapping[str, str] | None = None, ) -> str: if not is_coworking_scene(scene_text): return "" return scene_camera_directive(scene_text, parsed, pov_labels, subject_kind, compact_labels) def profile_composition_text(profile: dict[str, Any], subject_kind: str) -> str: composition = profile.get("composition") if isinstance(profile.get("composition"), dict) else {} if subject_kind == "woman" and composition.get("woman"): return str(composition["woman"]) if subject_kind == "man" and composition.get("man"): return str(composition["man"]) text = str(composition.get("default") or f"{profile['place']} frame with the subjects clearly placed in the room") if subject_kind == "couple": text = text.replace("the subjects", "the couple") if "composition" not in text.lower(): text = f"{text} composition" return text def contextual_composition_prompt( scene_text: Any, composition: Any, subject_kind: str = "subjects", *, scene_entry: Any = None, theme: Any = "", profile_key: Any = "", ) -> str: text = str(composition or "").strip() if not text: return text profile = scene_camera_profile(scene_text, scene_entry=scene_entry, theme=theme, profile_key=profile_key) if not profile: return text lower = text.lower() profile_lower = " ".join( str(profile.get(key, "")).lower() for key in ("place", "foreground", "midground", "background") ) already_matches = any(term and term in lower for term in profile_lower.replace(",", " ").split()) mismatched = any(term in lower for term in MISMATCHED_COMPOSITION_TERMS) office_generic = any(term in lower for term in ("office-lobby", "office lobby", "walking composition", "outfit-check")) if not mismatched and not office_generic and already_matches: return text if not mismatched and not office_generic and profile.get("family") != "coworking": return text return profile_composition_text(profile, subject_kind) def coworking_composition_prompt(scene_text: Any, composition: Any, subject_kind: str = "subjects") -> str: return contextual_composition_prompt(scene_text, composition, subject_kind) def camera_scene_directive_for_context( scene_text: Any, parsed_camera_config: dict[str, Any], pov_labels: list[str] | None = None, subject_kind: str = "subjects", compact_labels: Mapping[str, str] | None = None, *, scene_entry: Any = None, theme: Any = "", profile_key: Any = "", ) -> str: if ( parsed_camera_config.get("camera_detail") == "off" or parsed_camera_config.get("camera_mode") == "disabled" ): return "" return scene_camera_directive( scene_text, parsed_camera_config, pov_labels, subject_kind, compact_labels, scene_entry=scene_entry, theme=theme, profile_key=profile_key, )