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_id | the reference item's title, such as 2027 Audi US Order Guide (Invoice & Retail) |
content | the PDF bytes |
content_type | application/pdf |
source_url | the reference item's location, where the download starts |
fetched_at | the 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:
| listed | collected |
|---|---|
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 Schedule | no; 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:
- Can
user_cookies.sessions()produce a complete session? If not, the tick skips, with the reason as the skip reason. - Has the collection materialized since midnight, Eastern time? If so, the tick requests no collection.
- Is a run that the sensor started still in progress? If so, the tick requests no collection.
- 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,
WPSorWPT, aspr3_id, and the section's option code asordering_code. A content row'sparent_package_codeis the trim's public code too, soXPPis written asWPS. - 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
Sand 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_orderablemarks 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
contentsentries. The content row has the catalog row'sname. The entry's label determines a PR7 family:HEADLINERisHIM,STANDARD INLAYSisEIH,UPPER & LOWER DASHandSOFTWRAPareEIU, andCARPETINGhas 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: Grayshares no word withLight 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_type | read from |
|---|---|
trim | a trim section after the page's first, as an option of the model |
discount | a discount row at the end of a trim section, such as CRT, with a negative price |
option | the OPTIONS table |
accessory | Port Installed Accessories |
color | the exterior color matrix |
seat_trim | the 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 $-600that ends the 2026 guide's XPP and XPR sections; - its
contentsare the section's own STANDARD FEATURES lines, the equipment that the trim adds to the lower trims it includes; - its
qualifierandrulesare 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 mark | the row without a parent package | the rule added to its rules | content rows |
|---|---|---|---|
S | standard | none | none |
O or X | optional | excludes 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 X | optional | requires_one_of the higher trims that mark the code O or X | one per higher trim that marks the code S |
-, and no trim marks O or X | none | none | one 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
Sand 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, isO - -, so its row excludesXPPandXPR.3FU, the panoramic sunroof, isO S S, so its row excludesXPPandXPR, and it is a content row of each.WPR, the Technology package, is- O S, so its row requiresXPP, and it is inXPR'sincluded_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
metallicorpearl effectis priced at theMetallic or pearl effect paintcharge. - A color whose name contains
crystal effectis priced at theCrystal effect paintcharge. - 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,
QWrequiresYDHandYDHrequiresQW. - 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 guide | the rules |
|---|---|
req. WQB | requires_one_of [WQB] |
req. PPS or PQX | requires_one_of [PPS, PQX] |
n/a with PQX or PPS | excludes [PQX, PPS] |
req. XEP and UB interior | requires_one_of [XEP], requires_one_of [UB] |
req. XDA and XBL/XBR/XBE or XSP | requires_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_codeis"".
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/yysetsvalid_fromto that week's Monday.Before CW ww/yysetsvalid_toto 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 F | what is written |
|---|---|
req. WPT | inclusion: F requires WPT |
req. WS2 or WPT | inclusion: F requires WS2 or WPT |
N/A with WPT | exclusion: 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_ofrule over the family's codes, withrule_index-3; - for a PR family with a default code, an
inclusionwithrule_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_COLORfamily, aninclusionwithrule_index-4that 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'sGJ8cannot 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 includesEM3. - The PCT family has four unpriced seat colors that no package includes, so it has no default code.
- The FW and UO interiors include
5MCfrom the EIH family and the II interior includes5TK, so the EIH family has no default code. - The catalog marks
6NQstandard, but the FW and UO interiors include it. The default code of the HIM family is therefore the unpriced6NJ. The rule requires6NJonly when none of6NQ, 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).