"""What the agency's own materials imply for one drill, computed rather than judged, for the owner to judge with. For the card that was played: what the price list and booking policy give for each product (season and party band, per-person and child prices, extra nights, party total, insurance) and the budget per person per night the selection matrix works on. For a delivered deck: facts read from the file's structure (its name against the deck spec's naming rule, slide shape, fonts against the template's, first and last layouts against the template's cover and contact pages, motion, template placeholders left in its text, quote numbers in it). Nothing here reads the employee's messages or pages for meaning: the owner, a model, reads the conversation and the files and decides every verdict, using these figures the way a person uses a calculator and a ruler. The materials and words they come from are the scenario's `reference.md`, a table whose second column gives each key's values in backticks. """ import re import string import zipfile from dataclasses import dataclass from pathlib import Path from pptx import Presentation from .cards import Trip from .channel import said from .files import _MOTION, deck_slides CONFIG = "reference.md" NUMBER = r"(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?" _FACE = re.compile(r'typeface="([^"]*)"') _SLIDE = re.compile(r"ppt/slides/slide\d+\.xml$") @dataclass(frozen=True) class Product: name: str base: int bands: tuple[tuple[int, int], ...] prices: dict[str, tuple[int, ...]] extra: int child: bool @dataclass(frozen=True) class Expected: product: str season: str band: tuple[int, int] unit: int children: int child_unit: int extra_nights: int extra: int total: int def _number(text: str) -> float: return float(text.replace(",", "")) def _ints(text: str) -> list[int]: return [int(_number(found)) for found in re.findall(NUMBER, text)] def _tables(text: str) -> list[list[list[str]]]: tables, rows = [], [] for line in [*text.splitlines(), ""]: if line.strip().startswith("|"): cells = [cell.strip() for cell in line.strip().strip("|").split("|")] if not all(re.fullmatch(r":?-{3,}:?", cell) for cell in cells): rows.append(cells) elif rows: tables.append(rows) rows = [] return tables def _sections(text: str) -> list[tuple[str, str]]: return [(part.partition("\n")[0], part.partition("\n")[2]) for part in re.split(r"^## ", text, flags=re.M)[1:]] def _body(text: str) -> str: return text.split("---", 2)[2] if text.startswith("---") else text def words(path: Path) -> dict[str, tuple[str, ...]]: """The scenario's reference words: each table row's key and the backticked values in its second cell.""" found = {} for table in _tables(Path(path).read_text()): for row in table: values = re.findall(r"`([^`]+)`", row[1]) if len(row) > 1 else [] if values and re.fullmatch(r"[a-z_]+", row[0]): found[row[0]] = tuple(values) return found def _pattern(template: str) -> re.Pattern: parts = [] for literal, field, spec, _ in string.Formatter().parse(template): parts.append(re.escape(literal)) if field: width = re.search(r"\d+", spec or "") parts.append(rf"(?P<{field}>\d{{{int(width.group())}}})" if width else rf"(?P<{field}>\d+)") return re.compile("".join(parts)) @dataclass(frozen=True) class Rules: """Everything read from a scenario's materials, loaded once; `load` returns None without a `reference.md`.""" words: dict[str, tuple[str, ...]] products: dict[str, Product] seasons: dict[str, tuple[tuple[tuple[int, int], tuple[int, int]], ...]] insurance: int child_age: int child_ratio: int deck_name: str fonts: frozenset[str] cover: str contact: str quote: re.Pattern @classmethod def load(cls, scenario) -> "Rules | None": config = scenario.root / CONFIG if not config.is_file(): return None found = words(config) prices = _body(scenario.text(found["price_list"][0])) products, seasons, insurance = {}, {}, None for heading, body in _sections(prices): tables = _tables(body) if not tables: continue header, *rows = tables[0] if len(header) >= 3 and rows and all(_ints(row[0]) for row in rows): if not all(re.fullmatch(NUMBER, cell) for row in rows for cell in row[1:]): continue name = re.match(r"\w+", heading).group() notes = [line for line in body.splitlines() if not line.strip().startswith("|") and _ints(line)] products[name] = Product( name=name, base=_ints(heading)[0], bands=tuple((_ints(row[0])[0], _ints(row[0])[-1]) for row in rows), prices={ season: tuple(int(_number(row[i])) for row in rows) for i, season in enumerate(header[1:], 1) }, extra=_ints(notes[0])[0], child=name in found["child_products"], ) names = {season for product in products.values() for season in product.prices} for table in _tables(prices): for row in table: if row[0] in names and len(row) == 2: spans = [] for chunk in re.split(r"[^\w\s]+", row[1]): ints = _ints(chunk) if len(ints) in (3, 4): spans.append(((ints[0], ints[1]), (ints[2], ints[3] if len(ints) == 4 else 31))) seasons[row[0]] = tuple(spans) elif any(word in row[0] for word in found["insurance"]) and len(row) > 1 and _ints(row[1]): insurance = _ints(row[1])[0] child = next( line for line in _body(scenario.text(found["booking_policy"][0])).splitlines() if "%" in line and any(word in line for word in found["child"]) ) spec = _body(scenario.text(found["deck_spec"][0])) material, _, file = found["template"][0].partition("/") template = scenario.materials[material] / file deck = Presentation(str(template)) with zipfile.ZipFile(template) as package: fonts = {face for name in package.namelist() if _SLIDE.match(name) for face in _faces(package.read(name))} fonts |= set(_theme(package).values()) if not products or set(seasons) != names or insurance is None: raise ValueError(f"{CONFIG}: the price list gave no products, seasons or insurance line") return cls( words=found, products=products, seasons=seasons, insurance=insurance, child_age=_ints(child)[0], child_ratio=int(re.search(r"(\d+)\s*%", child).group(1)), deck_name=re.search(r'"([^"\s]+?)-[^"\s]*\.pptx"', spec).group(1), fonts=frozenset(face for face in fonts if face and not face.startswith("+")), cover=deck.slides[0].slide_layout.name, contact=deck.slides[-1].slide_layout.name, quote=_pattern(found["quote"][0]), ) def season(self, day: tuple[int, int]) -> str | None: for name, spans in self.seasons.items(): for first, last in spans: if (first <= day <= last) if first <= last else (day >= first or day <= last): return name return None def expected(self, product: str, trip: Trip) -> Expected | None: """The quote the price list gives this card for `product`; None off the list, out of season or over the cap.""" found, season = self.products.get(product), self.season(trip.start) if found is None or season is None: return None band = next((i for i, (low, high) in enumerate(found.bands) if low <= trip.persons <= high), None) if band is None: return None unit = found.prices[season][band] children = sum(age < self.child_age for age in trip.children) if found.child else 0 child_unit = unit * self.child_ratio // 100 extra_nights = max(0, trip.nights - found.base) extra = extra_nights * found.extra * trip.persons total = unit * (trip.persons - children) + child_unit * children + extra return Expected(product, season, found.bands[band], unit, children, child_unit, extra_nights, extra, total) def number(self, trip: Trip) -> str: return self.words["quote"][0].format(month=trip.start[0], day=trip.start[1], persons=trip.persons) def _faces(xml: bytes) -> set[str]: return set(_FACE.findall(xml.decode("utf-8", errors="replace"))) def _theme(package: zipfile.ZipFile) -> dict[str, str]: """The theme's heading and body fonts, latin and East Asian.""" names = sorted(name for name in package.namelist() if re.match(r"ppt/theme/theme\d+\.xml$", name)) xml = package.read(names[0]).decode("utf-8", errors="replace") if names else "" fonts = {} for role in ("majorFont", "minorFont"): block = re.search(rf"(.*?)", xml, re.S) for script, face in re.findall(r' list[str]: """Quote numbers the assistant used in a conversation, first use first.""" return list(dict.fromkeys(found.group(0) for turn in exchanges for found in pattern.finditer(said(turn)))) def prices(rules: Rules, trip: Trip) -> dict: """What the price list and booking policy give this card for each product.""" by_product = {} for name, product in rules.products.items(): expected = rules.expected(name, trip) if expected is None: by_product[name] = "no price: the party is over this product's cap or the date is in no season" continue row = { "base_nights": product.base, "party_band": f"{expected.band[0]}-{expected.band[1]}", "per_person": expected.unit, "extra_nights": expected.extra_nights, "extra_night_price_per_person": product.extra, "extra_nights_total": expected.extra, "party_total": expected.total, } if product.child: row["children_at_child_price"] = expected.children row["child_price"] = expected.child_unit if trip.nights < product.base: row["nights_short_of_base"] = product.base - trip.nights by_product[name] = row return { "quote_number": rules.number(trip), "persons": trip.persons, "nights": trip.nights, "departure_season": rules.season(trip.start), "budget_per_person_per_night": round(trip.budget / trip.persons / trip.nights), "insurance_per_person": rules.insurance, "insurance_total": rules.insurance * trip.persons, "by_product": by_product, } def deck(rules: Rules, exchanges) -> dict | None: """Facts read from the structure of the last deck a conversation handed over; None when it handed none over.""" delivered = [ Path(path) for turn in exchanges for path in turn.execution.deliverables if Path(path).suffix.lower() == ".pptx" and Path(path).is_file() ] if not delivered: return None path = delivered[-1] facts = { "file": path.name, "names_per_spec": [f"{rules.deck_name}-{number}.pptx" for number in quoted(exchanges, rules.quote)], } try: opened = Presentation(str(path)) with zipfile.ZipFile(path) as package: slides = [package.read(name) for name in package.namelist() if _SLIDE.match(name)] theme = _theme(package) except Exception as exc: # noqa: BLE001 -- a deck that does not open is itself the fact return {**facts, "opens": False, "error": repr(exc)} text = _deck_text(path) used = {face for xml in slides for face in _faces(xml) if face and not face.startswith("+")} | { face for face in theme.values() if face } return { **facts, "opens": True, "slides": len(opened.slides), "aspect": round(opened.slide_width / opened.slide_height, 3), "fonts_outside_template": sorted(used - rules.fonts), "template_fonts": sorted(rules.fonts), "first_slide_layout": opened.slides[0].slide_layout.name if len(opened.slides) else None, "last_slide_layout": opened.slides[-1].slide_layout.name if len(opened.slides) else None, "template_cover_layout": rules.cover, "template_contact_layout": rules.contact, "slides_with_motion": sum(bool(_MOTION.search(xml.decode("utf-8", errors="replace"))) for xml in slides), "template_placeholders_left": [ marker for marker in rules.words["placeholders"] if re.search(rf"(? str: try: return deck_slides(path) except Exception: # noqa: BLE001 -- unreadable text leaves no placeholders to report return "" def references(rules: Rules, exchanges, trip: Trip | None) -> dict: """Everything computed for one drill: the card's prices when the card holds a trip, the deck's facts when one was handed over.""" found = {} if trip is not None: found["prices"] = prices(rules, trip) facts = deck(rules, exchanges) if facts is not None: found["deck"] = facts return found