Skip to main content

Order guide assets

The order guide assets are:

  • the collection of guides, and the day's snapshot of it;
  • the models and the features derived from that snapshot;
  • both record sets mapped to the platform's model identity;
  • the rules parsed from the conditions on both record sets.

Every asset after the collection is partitioned daily. The collection is not, because AccessAudi has one current library, not a set of documents per day.

consolidated/models reads the enriched models, and consolidated/features the enriched features, each as its highest-priority source. See model identity. consolidated/rules reads the enriched rules and the PR family rules, which enriched/family_rules derives from consolidated/features.

raw/order_guides_latest and raw/order_guides​

AccessAudiRawComponent defines every asset collected from AccessAudi. Each AccessAudi resource gets a collection asset and a snapshot asset.

raw/order_guides_latest is unpartitioned, with one row per guide the library has now:

column
document_idthe reference item's title, such as 2027 Audi US Order Guide (Invoice & Retail)
contentthe PDF bytes
content_typeapplication/pdf
source_urlthe reference item's location, where the download starts
fetched_atthe time of the fetch

raw/order_guides has the same rows with _partition_date added first. The column is both the day the snapshot is for and the Iceberg partition column.

fetched_at is copied from the collection and not set again, so a partition shows how old its bytes are. A snapshot of a collection from the previous morning has that morning's timestamp.

There are two assets because of the sign-in. A session exists only after a person signs in, so the collection cannot run on a schedule. Every tier after it is partitioned by day, and processing a day again must read the same bytes as the first time. The collection therefore holds the current library, and the snapshot copies it into a dated partition.

Audi reissues a guide under the same name. The snapshot keeps each day's version, and the parser reads a guide's model year from the document instead of the partition.

Neither asset writes an empty table. Audi always publishes guides for the current model years, so a collection that finds no guide has failed. A snapshot of an empty library would remove every model from the tables while the materialization still succeeds.

ai_audi.sources.order_guides.fetch_order_guides collects the guides. It reads AccessAudi's whole reference library once through ai_access_audi.get_documents, then selects the Order Guides from that list.

fetch_document follows each guide to its content, which takes several redirects per guide. pdf_bytes then checks the content for the %PDF- signature, because AccessAudi's content types are inconsistent.

The list has two guides per model year, and only one has invoice prices:

listedcollected
2027 Audi US Order Guide (Invoice & Retail)yes
2027 Audi US Order Guide (Retail)no; the same tables, with retail prices only
2026 Audi US Order Guide (Invoice & Retail)yes
2026 Audi US Order Guide (Retail)no
2025 Audi US Order Guide (Invoice & Retail)yes; collected, but not parsed by the transformed tier
2025 Audi US Order Guide (Retail)no
2024 Audi US Order Guide (Invoice & Retail)yes; collected, but not parsed by the transformed tier
Sailing Scheduleno; not a guide

The selection is by title, not by year, so a new model year is collected without a code change. The transformed tier's min_model_year determines which model years reach the tables.

AccessAudi requires a dealer sign-in for the library, and the session is a browser sign-in, not a static credential. Cookie Monster records these sessions, so the asset reads one from Cookie Monster's database and holds no credential itself. The user_cookies resource opens its own connection to that database. The cookies of a session depend on the OEM, so ai_audi's own definitions register the resource instance: the audi_user_info collection, and the three cookies that the ordering service authenticates with, since it is the same sign-in.

Unlike ordering, any dealer's session works. A reference document is the same library page for every dealer, so there is no dealership to select and no dealer to verify. The session only has to be complete. An incomplete session reaches the sign-in page instead of the library, which arrives as a document that is not a PDF instead of as a missing session. An expired session raises AccessAudiAuthError.

The resource offers only sessions that Cookie Monster saw in the last two hours (max_session_age_hours). Cookie Monster refreshes Audi sessions every 30 minutes and updates lastSeen on each successful refresh, so a working session is never older than that.

fetch_document distinguishes the library from the sign-in page by the content, not the content type, because AccessAudi sends a login page as application/octet-stream, as application/zip, or with no content type. Only content that begins like a web page is searched for the sign-in markers. Anything else is a download, so a document that contains the word SAMLRequest is not taken for an expired session.

What starts the collection​

A session exists only after someone at a dealership signs in, and the asset cannot create one. It can only wait for Cookie Monster to record the next one, so the collection has no automation condition and no cron schedule. The audi_us_accessaudi sensor (AccessAudiSensorComponent in raw/defs.yaml) starts it instead. The same sensor checks the allocation window (Allocation Windows).

Every poll_seconds (default 30 minutes) during its business hours, a sensor tick checks, in order:

  1. Can user_cookies.sessions() produce a complete session? If not, the tick skips, with the reason as the skip reason.
  2. Has the collection materialized since midnight, Eastern time? If so, the tick requests no collection.
  3. Is a run that the sensor started still in progress? If so, the tick requests no collection.
  4. Has the sensor already requested a run with the freshest session today? If so, the tick requests no collection until Cookie Monster records a different session.

Otherwise the tick requests a run and records the time and a hash of the session in its cursor. A run with a session that AccessAudi refuses writes nothing, so the collection stays due. The next sign-in starts another run. When AccessAudi fails, the sensor therefore retries it with each new session, or with the same session on the next day, instead of every 30 minutes. The freshness policy below reports a collection that has stopped running.

Targets must be unpartitioned, and the sensor raises on a partitioned one. A run request without a partition cannot materialize a partitioned asset, and a collection of the source's current state has no partition.

Waiting therefore costs a sensor tick in the code server, not an idle ECS task.

When it is unhealthy​

raw/order_guides_latest has its own freshness policy: FreshnessPolicy.time_window(fail_window=stale_after_hours), set to 80 hours in raw/defs.yaml, so it alerts only when no collection has succeeded for more than three days.

A time window fits because the collection has no schedule. A daily deadline would report it late whenever nobody signed in, which the on-call engineer cannot act on. A library more than 80 hours old is actionable: someone needs to sign in.

apply_freshness_policy keeps that policy. The deployment's cron deadline is the default for a daily feed, and applies only to an asset without a policy of its own. The daily snapshot has none, so the deadline applies to it.

A period without sign-ins therefore produces skipped ticks and then a sentry_freshness_sensor alert.

A collection that authenticated but found no guide is a different case, and it fails the run.

transformed/order_guides_{models,features}​

AudiOrderGuidesComponent is one multi-asset over the raw partition. It parses every guide in the partition from min_model_year on with ai_access_audi.order_guides.parser, derives both record sets, and runs clean per entity. A code in two tables of one guide, or in several guides of one partition, becomes one row.

Each guide's model year is read from its title, the raw document_id, which begins with it. The year is compared to min_model_year before the PDF is opened. The library keeps the 2024 and 2025 guides beside the current ones. Those model years are closed to ordering, and their layouts are not supported by the parser: the 2024 guide covers its header rows with a diagonal overlay, and the 2025 guide has credit rows without an option code. audi/us sets min_model_year: 2026, and a guide before that year is logged and not parsed.

Three cases fail the partition instead of losing rows:

  • no guide in the partition is parsed;
  • a guide parses to no models or no features, which is a parser failure;
  • a guide's trim sections and availability mark columns have different trims.

A page has its trims twice: in the TRIM column of the STANDARD FEATURES table, and as the availability mark columns of the OPTIONS table. Only a trim section has a trim's option code and price. A trim that only the OPTIONS columns have would be missing from both tables. A trim that only a section has would have nothing available in a table whose columns lack it. The failure message gives the table.

The accessories page is exempt from the check that every mark column has a section. It always has the three trim columns of the Audi brand, whatever trims the model has. The 2027 S6 Sportback e-tron's accessories page has a PREMIUM column, but its sections are PREMIUM PLUS and PRESTIGE. The 2026 Q4 pages have a PRESTIGE column, but their sections are PREMIUM and PREMIUM PLUS. A column there without a matching section is not a trim of the model, and _mark never looks it up.

A page whose sections all have no name is a different case. Its columns are combined into the single section, with the strongest mark of any column. The 2026 RS 3 has three named mark columns and one unnamed section. Keying the columns by a name that the section does not have would drop every marked row on that page.

Records​

ai_audi.sources.order_guides defines the records derived from a document. Nothing there opens a PDF. Every input is a field of AudiGuideDocument, so a derivation can be tested with a document written in the test (tests/sources/test_order_guides.py).

Models. One row per production window of every model page, keyed on (model_code, sales_model_year, build_window). The row is read from the window's first trim section, which is the base trim's section. Each higher trim is a feature of the model, described under Features below. msrp is the base price in the header, plus any discount row in the base section. name is the vehicle's name, without a trim.

The guides are the only Audi source with an invoice price, the destination and metallic-paint charges, a mid-year production window, and whether a model is open for ordering. is_orderable comes from the contents page, which has Not Available for Ordering in the name cell of a closed model. A model the contents page does not list gets null.

contents is the base section's STANDARD FEATURES lines as printed. The lines have no option codes.

qualifier is the red text under the base trim's name, and rules is its meaning. A higher trim's qualifier is on its feature row. In the US guides, no base trim section has a qualifier. The only trim section that has one is the PRESTIGE section of the Q7 model pages, with req. MP, RJ or RH interior.

enriched/order_guides_models​

OrderGuidesEnrichmentComponent has one asset over the transformed models. It maps each model to the platform's identity, (model_code, sales_model_year), and keeps one row per identity. Model identity describes how a higher trim becomes a feature.

A model that changes mid-year has each production window on its own header page, and the ordering system changes the trim sections' codes at that point. The 2026 A6 Sedan orders Premium Plus as WPS before CW 05/26 and as XPP from then on. The 2027 Q6 e-tron and A6 Sportback e-tron lines do the same at CW 36/26.

The row of the production window in effect on the partition date is kept. That is the latest window whose start, the Monday of its CW ww/yy, is on or before the partition date. A Before CW … window, and a null build_window, start before every dated window. If none of a model's windows has started, its earliest is kept. A dated window that the pattern cannot parse fails the partition.

enriched/order_guides_features​

The same component has one asset over the transformed features and enriched/catalog_features. Each row is keyed on (model_code, sales_model_year, pr3_id, parent_package_code).

  • A trim's row has its public code, WPS or WPT, as pr3_id, and the section's option code as ordering_code. A content row's parent_package_code is the trim's public code too, so XPP is written as WPS.
  • The guide lists few of a trim's contents by code. It has a content row only for a code that its OPTIONS or accessories table marks S and that is not a package. The trim's STANDARD FEATURES lines have no codes.
  • Every production window's codes stay, because a vehicle built in either window has that window's codes. is_orderable marks the rows of the window in effect on the partition date.
  • A content row is not orderable, because AccessAudi orders a trim or package by its own code (see Ordering decisions).
  • Where the window in effect lists a code, the code's rows of other windows are dropped. This includes rows under another parent package, because one window can list a code on its own and the next only inside a trim.
  • A feature that one window offers under a different code for each interior is one row, with the codes in ordering_codes_by_interior. Model identity describes it.
  • A seat trim has a content row for the catalog code of each of its contents entries. The content row has the catalog row's name. The entry's label determines a PR7 family: HEADLINER is HIM, STANDARD INLAYS is EIH, UPPER & LOWER DASH and SOFTWRAP are EIU, and CARPETING has none. Within that family, on the same model, the code is the catalog row that shares the most words with the entry's text, where at least two words in five are shared and no second row has the same count. An entry that matches no row has no code: HEADLINER: Gray shares no word with Light cloth headliner.

Features. One row per coded option of each production window, keyed on (model_code, sales_model_year, build_window, pr3_id, parent_package_code). Five tables on a model page have codes, and so does each trim section. feature_type records which of them a row is read from:

feature_typeread from
trima trim section after the page's first, as an option of the model
discounta discount row at the end of a trim section, such as CRT, with a negative price
optionthe OPTIONS table
accessoryPort Installed Accessories
colorthe exterior color matrix
seat_trimthe matrix's seat-trim columns

A trim is an option of the model. AccessAudi orders a higher trim as an option on the base model. The trim's row takes its values from the trim's own section:

  • its price and invoice are the section's upgrade plus the section's discount, such as the CRT $-600 that ends the 2026 guide's XPP and XPR sections;
  • its contents are the section's own STANDARD FEATURES lines, the equipment that the trim adds to the lower trims it includes;
  • its qualifier and rules are the section's, with a requirement of the section's discount code where it has one.

A code's marks determine its rows. A row of the OPTIONS or accessories table has a mark under each trim column. S marks it standard on that trim, X and O optional, and - not available. A code is ordered on its own only on the trims that mark it O or X. A higher trim that marks it S includes it. The marks determine these rows:

the base trim's markthe row without a parent packagethe rule added to its rulescontent rows
Sstandardnonenone
O or Xoptionalexcludes each higher trim that marks the code S or -one per higher trim that marks the code S
-, and a higher trim marks O or Xoptionalrequires_one_of the higher trims that mark the code O or Xone per higher trim that marks the code S
-, and no trim marks O or Xnonenoneone per higher trim that marks the code S

A content row has the trim's option code as parent_package_code. Like the contents of any optional package, it has is_standard and is_configurable true.

A package, an OPTIONS row with lines beneath its heading, gets no content row. Its lines are text without option codes. The public catalog and inventory list the contents of a package that a trim includes by their own codes, never by the package code. A higher trim that marks a package S lists the package's code, name and lines in its row's included_packages instead. The enriched tier drops the column.

The partition fails in these cases:

  • a code that the base trim marks S and a higher trim does not, because no row can state that a trim removes equipment;
  • a page without a trim section;
  • a higher trim section whose option code is not a trim code in TRIM_NORMALIZE;
  • a code that two tables of one production window list with different rules, because the transformed tier keeps one row of the code;
  • a discount code that two trims list with different amounts, because the code has one row, the lower trim's.

On the 2027 guide's page for the Q6 e-tron quattro from CW 36/26 (page 46 of the 2026-08-10 edition, page 56 of the 2026-10-05 edition):

  • WPD, the Convenience package, is O - -, so its row excludes XPP and XPR.
  • 3FU, the panoramic sunroof, is O S S, so its row excludes XPP and XPR, and it is a content row of each.
  • WPR, the Technology package, is - O S, so its row requires XPP, and it is in XPR's included_packages.

In rules, the added rule comes after the conditions the guide prints. A content row has only the printed conditions. A row of a table without trim columns is available on the page's single trim and gets no rule from marks.

A color is priced at the header's paint charge. The color matrix has no prices. A model's header has a Metallic or pearl effect paint charge, and some models' headers also have a Crystal effect paint charge. Each charge has a retail and an invoice amount.

  • A color whose name contains metallic or pearl effect is priced at the Metallic or pearl effect paint charge.
  • A color whose name contains crystal effect is priced at the Crystal effect paint charge.
  • Any other color, such as Arkona White, has no price.

Where the header prints a charge as -, as on the 2027 Q9 and A8 L, the colors that the charge applies to have no price.

A seat-trim code is the seat's color, so GX is Black. The heading above its column is the material, which is ordered through the trim section or a package, not through the code. The 2026 SQ5 has GX under Leather/Dinamica and again under Fine Nappa / Milano, and its warm weather package XWO (req. GX) adds the Fine Nappa. A page with one code under two headings therefore offers one seat in several ways, and produces one row.

A seat has no parent package. A seat is ordered with the paint, not as part of a package, so the requirements in a column's heading are conditions for having the seat. They are written to rules.

A seat's contents is the interior that comes with it, from the page's INTERIOR COMPONENT OPTIONS table. Each entry is one printed cell, prefixed with the column's label: HEADLINER: Black, STANDARD INLAYS: Carbon micro-twill structure. The dash column's label is UPPER & LOWER DASH, whether the page's heading is UPPER & LOWER DASH or DASHBOARD. A page with a SOFTWRAP column instead produces a SOFTWRAP entry.

A heading has that condition in one of two forms: an order code next to the trim code, as in the 2027 A5's (FW) XBL, or a qualifier, as in the 2027 A6 Sedan's (FW) (req. PWW). The two forms mean the same, and a heading with both counts once: the 2027 SQ6 Sportback e-tron's QM column has the heading YDH and also the qualifier req. YDH.

A condition in only some of a code's columns is not a condition for the seat, because each column is another way to order it. The 2027 A6 Sportback e-tron has FW without a qualifier, and again under req. PWE/PWF, so FW can be ordered without either package, and the row gets no rule. Only the conditions of every column with the code are kept, and no seat row has more than one.

One qualifier can cover several columns and give a rule per code, keyed by the code. The 2026 S3's two Fine Nappa Leather columns have the heading Req. PWN for EI/ PWO for AR, so under that heading EI requires PWN and AR requires PWO. EI also has a Leatherette / Dinamica column without a qualifier, so on the S3, EI has no condition and AR requires PWO.

Where the columns differ, the qualifier text still has each column's requirement, followed by the heading of that column: the S3's EI row reads Req. PWN under Fine Nappa Leather. A heading without a qualifier is not mentioned. The text and the empty rules therefore mean the same: the seat is available without a condition under the heading that the text does not mention.

Keeping these conditions in rules and not in parent_package_code has two advantages:

  • Two codes that each require the other stay one row instead of two. On the SQ6 Sportback e-tron, QW requires YDH and YDH requires QW.
  • It matches AccessAudi, where an interior color is ordered with the paint and has no parent.

How a rule is written​

rules holds ai_core.entities.OptionRule, which both the Audi and the Stellantis records use. A rule has a type, either requires_one_of or excludes, and the codes it applies to. Every rule on a record must hold, so these two types cover every condition in the guides:

in the guidethe rules
req. WQBrequires_one_of [WQB]
req. PPS or PQXrequires_one_of [PPS, PQX]
n/a with PQX or PPSexcludes [PQX, PPS]
req. XEP and UB interiorrequires_one_of [XEP], requires_one_of [UB]
req. XDA and XBL/XBR/XBE or XSPrequires_one_of [XDA, XSP], requires_one_of [XBL, XBR, XBE, XSP]

A qualifier that requires several codes produces one rule per code, because a rule with a single code requires that code.

A qualifier with a choice between whole combinations produces the rules that hold for every choice. The 2027 A5's Vorsprung package requires XDA plus one of three Executive packages, or XSP alone. XSP alone satisfies both of its rules, and an Executive package without XDA satisfies neither.

The text stays on the record in qualifier. A seat-trim row keeps the part of the qualifier that applies to its own code, followed by its heading where the columns with the seat differ. Every other row has the qualifier as printed.

A color's row in the interior matrix is also a constraint, so it is written to rules together with the rules of its own qualifier. A color available with only some of a page's seat-trim codes requires one of those codes. Pages with one interior instead of a grid state the same requirement in words, as req. EI interior. A color available with every code has no constraint and gets no rule.

A code can head two columns, so a color is available with the union of the codes over its marked columns: a color marked under either FW column is available with FW.

The marks are matched to the page's columns by position, because a page can have one seat-trim code in two columns under different seat styles. A column without a mark in the row means the two were parsed from different grids, and that raises. A row with more marks than columns means the parser could not read one column's code. That column's codes are lost, but the partition does not fail.

A discount's is_configurable is false, because a vehicle of its trim gets the code whatever else is ordered. It appears as a feature row as well as in its trim's price, so the feature rows include every code the vehicle has. A discount in the base section has is_standard true. A higher trim's discount is neither standard nor a content row of the trim, because an order does not send a package's contents. The trim's own rule requires it. Where two trims have the same discount code, the row is the lower trim's.

enriched/order_guides_rules​

AudiOrderGuideRulesComponent has one asset over both transformed record sets. A guide prints a condition next to a feature row and under a trim section's name. Each OptionRule on either record becomes one ai_core.entities.RuleEntity row, keyed on (model_code, sales_model_year, subject_code, rule_index).

A rule constrains the codes an order selects. A vehicle that has a code as a trim's content does not select it, so a Prestige vehicle with the sunroof satisfies 3FU excludes WPT. An order selects a code only by its row without a parent package, so only that row produces rules. Where the window in effect lists a code, only that window's rows produce the code's rules. SyntheticCandidatesComponent checks these rules as Codes a package includes describes.

requires_one_of becomes an inclusion, and excludes an exclusion. These match the meanings in the rules entity: an inclusion requires at least one of its THEN codes, and an exclusion forbids every one of them. The codes in the condition are the THEN parts.

The row that the condition is printed on determines the IF part:

  • A feature row's condition applies to that feature, which is the IF part.
  • A higher trim section's condition is on the trim's row, so it is a feature row's condition, with the trim's code as its subject_code.
  • The model row's condition, printed under the base trim's name, applies to the whole model, so the IF part is empty, and subject_code is "".

A model row has its own is_orderable, which records whether the contents page lists the model as open for ordering. A rule uses is_orderable in the feature rows' meaning, the production window in effect, so the model's value is dropped.

code is null, because the guides do not number rules. rule_index is the condition's position in the qualifier as printed, which distinguishes two conditions of one row.

A code is rewritten to the public catalog's form through ai_audi.ordering_codes, on the subject and on every code in the condition, because consolidated features are keyed on the public code. The codes of a feature that the guide offers under a different code for each interior are one subject. The conditions that require each code's interior become one inclusion that requires one of the interiors. On the 2027 A5, WPS requires FW, II or NK.

validity comes from the row's production window:

  • From … CW ww/yy sets valid_from to that week's Monday.
  • Before CW ww/yy sets valid_to to the day before that Monday.
  • A row without a window has no bounds.

The rows are then reduced to one per rule identity, the window in effect on the partition date, in the same way as the enriched features. A rule and its feature therefore describe the same production window.

A condition on a trim​

A guide has conditions on trims as well as on features. Most of them are on seat trims, which have no availability matrix of their own. The 2026 Q7 offers RH only with req. WPT, and N/A with WPT makes MN and AD unavailable on that trim.

A higher trim is a feature of its model, so a trim code in a condition is a rule part like any other code. XPP and XPR are written as WPS and WPT, the codes of the trims' features:

the condition on feature Fwhat is written
req. WPTinclusion: F requires WPT
req. WS2 or WPTinclusion: F requires WS2 or WPT
N/A with WPTexclusion: F forbids WPT

A build has at most one of its model's higher trims. Where a model has two, an only_one_of rule over their codes has subject_code "" and rule_index -2.

The rule that the marks add to a feature's rules becomes a rule row, as a printed condition does. Its rule_index is its position after the printed conditions, and its qualifier is the row's. The 2026 Q5's WQB, optional only on Premium Plus and Prestige, requires WPS or WPT. The 2027 Q6 e-tron quattro's WPD excludes WPS and WPT.

The 2026 Q7's Prestige requires the MP, RJ or RH interior. The condition is printed under the trim name and parsed onto the trim's row:

rule_type     inclusion
rule_if [{'feature_code': 'WPT', 'negated': False}]
rule_then [{'feature_code': 'MP'}, {'feature_code': 'RJ'}, {'feature_code': 'RH'}]
model_code 4MQAX2
subject_code WPT

enriched/family_rules​

Each Audi PR code belongs to one PR family. A build has at most one code of each family, and exactly one code of most families. A build also has one paint and one interior. Paints and interiors have no PR family, so AudiFamilyRulesComponent puts the codes of the EXTERIOR_COLOR and EXCLUSIV_EXTERIOR_COLOR categories in an EXTERIOR_COLOR family, and the codes of the INTERIOR_COLOR category in an INTERIOR_COLOR family.

For each model code, model year and family with at least two codes in consolidated/features, the component writes:

  • an only_one_of rule over the family's codes, with rule_index -3;
  • for a PR family with a default code, an inclusion with rule_index -4. It requires the default code when no other code of the family is present and no package that includes another code of the family is present. Each of those codes and packages is a negated IF part, and the default code is the one THEN code;
  • for the INTERIOR_COLOR family, an inclusion with rule_index -4 that requires one of the family's codes on every build. Its IF part is empty, and its THEN codes are the family's codes.

The EXTERIOR_COLOR family has no inclusion.

The default code is the family's one code that no package includes and that the catalog marks standard. Where the catalog marks none of those codes standard, it is the one code that no package includes and that has no price. A family with no such code, or with more than one, has no default code. An interior that includes a code counts as a package that includes it. The component reads a code's family and the packages that include it from all of the code's rows, because a package's content row can have no pr_family. On the 2027 Q5:

  • The default code of the STT family is GJ0, which the catalog marks standard. The family's GJ8 cannot be the default code, because the Driver assistance package (WPR) includes it.
  • The catalog does not list the MKE family, so it marks no MKE code standard. The default code of the family is EM2, because WPR includes EM3.
  • The PCT family has four unpriced seat colors that no package includes, so it has no default code.
  • The FW and UO interiors include 5MC from the EIH family and the II interior includes 5TK, so the EIH family has no default code.
  • The catalog marks 6NQ standard, but the FW and UO interiors include it. The default code of the HIM family is therefore the unpriced 6NJ. The rule requires 6NJ only when none of 6NQ, FW and UO is present.

The inclusion of the floor-mat family, ZFM, also has a negated IF part for each ACCESSORY feature of the model code and model year whose name or description mentions all-weather mats, because a car with such an accessory has no front and rear floor mats. The accessories are not in the ZFM family, because a car with one can also have a code of that family, such as the Audi exclusive floor mats (0TF).

In each rule, subject_code is the family and code is family:<family>. The PR family of a code comes from the catalog or from OneGraph inventory, whichever consolidated/features takes it from.

SyntheticCandidatesComponent reads each only_one_of rule as an exclusive group (see Synthetic Candidates). It meets an inclusion that a candidate fails by adding a THEN code (see Compatibility rules). It drops a base-year inventory record without an interior as incomplete (see Incomplete base configs).